Branch data Line data Source code
1 : : /* Definitions for C++ name lookup routines.
2 : : Copyright (C) 2003-2024 Free Software Foundation, Inc.
3 : : Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
4 : :
5 : : This file is part of GCC.
6 : :
7 : : GCC is free software; you can redistribute it and/or modify
8 : : it under the terms of the GNU General Public License as published by
9 : : the Free Software Foundation; either version 3, or (at your option)
10 : : any later version.
11 : :
12 : : GCC is distributed in the hope that it will be useful,
13 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : : GNU General Public License for more details.
16 : :
17 : : You should have received a copy of the GNU General Public License
18 : : along with GCC; see the file COPYING3. If not see
19 : : <http://www.gnu.org/licenses/>. */
20 : :
21 : : #include "config.h"
22 : : #define INCLUDE_MEMORY
23 : : #include "system.h"
24 : : #include "coretypes.h"
25 : : #include "cp-tree.h"
26 : : #include "timevar.h"
27 : : #include "stringpool.h"
28 : : #include "print-tree.h"
29 : : #include "attribs.h"
30 : : #include "debug.h"
31 : : #include "c-family/c-pragma.h"
32 : : #include "gcc-rich-location.h"
33 : : #include "spellcheck-tree.h"
34 : : #include "parser.h"
35 : : #include "c-family/name-hint.h"
36 : : #include "c-family/known-headers.h"
37 : : #include "c-family/c-spellcheck.h"
38 : : #include "bitmap.h"
39 : :
40 : : static cxx_binding *cxx_binding_make (tree value, tree type);
41 : : static cp_binding_level *innermost_nonclass_level (void);
42 : : static void set_identifier_type_value_with_scope (tree id, tree decl,
43 : : cp_binding_level *b);
44 : : static name_hint maybe_suggest_missing_std_header (location_t location,
45 : : tree name);
46 : : static name_hint suggest_alternatives_for_1 (location_t location, tree name,
47 : : bool suggest_misspellings);
48 : :
49 : : /* Slots in BINDING_VECTOR. */
50 : : enum binding_slots
51 : : {
52 : : BINDING_SLOT_CURRENT, /* Slot for current TU. */
53 : : BINDING_SLOT_GLOBAL, /* Slot for merged global module. */
54 : : BINDING_SLOT_PARTITION, /* Slot for merged partition entities or
55 : : imported friends. */
56 : :
57 : : /* Number of always-allocated slots. */
58 : : BINDING_SLOTS_FIXED = BINDING_SLOT_GLOBAL + 1
59 : : };
60 : :
61 : : /* Create an overload suitable for recording an artificial TYPE_DECL
62 : : and another decl. We use this machanism to implement the struct
63 : : stat hack. */
64 : :
65 : : #define STAT_HACK_P(N) ((N) && TREE_CODE (N) == OVERLOAD && OVL_LOOKUP_P (N))
66 : : #define STAT_TYPE_VISIBLE_P(N) TREE_USED (OVERLOAD_CHECK (N))
67 : : #define STAT_TYPE(N) TREE_TYPE (N)
68 : : #define STAT_DECL(N) OVL_FUNCTION (N)
69 : : #define STAT_VISIBLE(N) OVL_CHAIN (N)
70 : : #define MAYBE_STAT_DECL(N) (STAT_HACK_P (N) ? STAT_DECL (N) : N)
71 : : #define MAYBE_STAT_TYPE(N) (STAT_HACK_P (N) ? STAT_TYPE (N) : NULL_TREE)
72 : :
73 : : /* When a STAT_HACK_P is true, OVL_USING_P and OVL_EXPORT_P are valid
74 : : and apply to the hacked type. */
75 : :
76 : : /* For regular (maybe) overloaded functions, we have OVL_HIDDEN_P.
77 : : But we also need to indicate hiddenness on implicit type decls
78 : : (injected friend classes), and (coming soon) decls injected from
79 : : block-scope externs. It is too awkward to press the existing
80 : : overload marking for that. If we have a hidden non-function, we
81 : : always create a STAT_HACK, and use these two markers as needed. */
82 : : #define STAT_TYPE_HIDDEN_P(N) OVL_HIDDEN_P (N)
83 : : #define STAT_DECL_HIDDEN_P(N) OVL_DEDUP_P (N)
84 : :
85 : : /* Create a STAT_HACK node with DECL as the value binding and TYPE as
86 : : the type binding. */
87 : :
88 : : static tree
89 : 504044 : stat_hack (tree decl = NULL_TREE, tree type = NULL_TREE)
90 : : {
91 : 504044 : tree result = make_node (OVERLOAD);
92 : :
93 : : /* Mark this as a lookup, so we can tell this is a stat hack. */
94 : 504044 : OVL_LOOKUP_P (result) = true;
95 : 504044 : STAT_DECL (result) = decl;
96 : 504044 : STAT_TYPE (result) = type;
97 : 504044 : return result;
98 : : }
99 : :
100 : : /* Create a local binding level for NAME. */
101 : :
102 : : static cxx_binding *
103 : 770807864 : create_local_binding (cp_binding_level *level, tree name)
104 : : {
105 : 770807864 : cxx_binding *binding = cxx_binding_make (NULL, NULL);
106 : :
107 : 770807864 : LOCAL_BINDING_P (binding) = true;
108 : 770807864 : binding->scope = level;
109 : 770807864 : binding->previous = IDENTIFIER_BINDING (name);
110 : :
111 : 770807864 : IDENTIFIER_BINDING (name) = binding;
112 : :
113 : 770807864 : return binding;
114 : : }
115 : :
116 : : /* Find the binding for NAME in namespace NS. If CREATE_P is true,
117 : : make an empty binding if there wasn't one. */
118 : :
119 : : static tree *
120 : 8018902371 : find_namespace_slot (tree ns, tree name, bool create_p = false)
121 : : {
122 : 8018902371 : tree *slot = DECL_NAMESPACE_BINDINGS (ns)
123 : 15686781028 : ->find_slot_with_hash (name, name ? IDENTIFIER_HASH_VALUE (name) : 0,
124 : : create_p ? INSERT : NO_INSERT);
125 : 8018902371 : return slot;
126 : : }
127 : :
128 : : static tree
129 : 35926 : find_namespace_value (tree ns, tree name)
130 : : {
131 : 35926 : tree *b = find_namespace_slot (ns, name);
132 : :
133 : 35926 : return b ? MAYBE_STAT_DECL (*b) : NULL_TREE;
134 : : }
135 : :
136 : : /* Look in *SLOT for a the binding of NAME in imported module IX.
137 : : Returns pointer to binding's slot, or NULL if not found. Does a
138 : : binary search, as this is mainly used for random access during
139 : : importing. Do not use for the fixed slots. */
140 : :
141 : : static binding_slot *
142 : 207097 : search_imported_binding_slot (tree *slot, unsigned ix)
143 : : {
144 : 207097 : gcc_assert (ix);
145 : :
146 : 207097 : if (!*slot)
147 : : return NULL;
148 : :
149 : 207097 : if (TREE_CODE (*slot) != BINDING_VECTOR)
150 : : return NULL;
151 : :
152 : 207097 : unsigned clusters = BINDING_VECTOR_NUM_CLUSTERS (*slot);
153 : 207097 : binding_cluster *cluster = BINDING_VECTOR_CLUSTER_BASE (*slot);
154 : :
155 : 207097 : if (BINDING_VECTOR_SLOTS_PER_CLUSTER == BINDING_SLOTS_FIXED)
156 : : {
157 : 207097 : clusters--;
158 : 207097 : cluster++;
159 : : }
160 : :
161 : 414596 : while (clusters > 1)
162 : : {
163 : 402 : unsigned half = clusters / 2;
164 : 402 : gcc_checking_assert (cluster[half].indices[0].span);
165 : 402 : if (cluster[half].indices[0].base > ix)
166 : : clusters = half;
167 : : else
168 : : {
169 : 258 : clusters -= half;
170 : 258 : cluster += half;
171 : : }
172 : : }
173 : :
174 : 207097 : if (clusters)
175 : : /* Is it in this cluster? */
176 : 413951 : for (unsigned off = 0; off != BINDING_VECTOR_SLOTS_PER_CLUSTER; off++)
177 : : {
178 : 413951 : if (!cluster->indices[off].span)
179 : : break;
180 : 413951 : if (cluster->indices[off].base > ix)
181 : : break;
182 : :
183 : 413951 : if (cluster->indices[off].base + cluster->indices[off].span > ix)
184 : 207097 : return &cluster->slots[off];
185 : : }
186 : :
187 : : return NULL;
188 : : }
189 : :
190 : : static void
191 : 208243 : init_global_partition (binding_cluster *cluster, tree decl)
192 : : {
193 : 208243 : bool named = true;
194 : :
195 : 208243 : if (header_module_p ())
196 : : named = false;
197 : 208179 : else if (TREE_PUBLIC (decl)
198 : 208179 : && TREE_CODE (decl) == NAMESPACE_DECL
199 : 209577 : && !DECL_NAMESPACE_ALIAS (decl))
200 : : named = false;
201 : 206781 : else if (!get_originating_module (decl))
202 : : named = false;
203 : :
204 : 0 : binding_slot *mslot;
205 : 0 : if (named)
206 : 0 : mslot = &cluster[BINDING_SLOT_PARTITION
207 : : / BINDING_VECTOR_SLOTS_PER_CLUSTER]
208 : : .slots[BINDING_SLOT_PARTITION
209 : : % BINDING_VECTOR_SLOTS_PER_CLUSTER];
210 : : else
211 : 208243 : mslot = &cluster[0].slots[BINDING_SLOT_GLOBAL];
212 : :
213 : 208243 : if (*mslot)
214 : 43988 : decl = ovl_make (decl, *mslot);
215 : 208243 : *mslot = decl;
216 : :
217 : 208243 : if (TREE_CODE (decl) == CONST_DECL)
218 : : {
219 : 8168 : tree type = TREE_TYPE (decl);
220 : 8168 : if (TREE_CODE (type) == ENUMERAL_TYPE
221 : 8168 : && IDENTIFIER_ANON_P (DECL_NAME (TYPE_NAME (type)))
222 : 13643 : && decl == TREE_VALUE (TYPE_VALUES (type)))
223 : : /* Anonymous enums are keyed by their first enumerator, put
224 : : the TYPE_DECL here too. */
225 : 419 : *mslot = ovl_make (TYPE_NAME (type), *mslot);
226 : : }
227 : 208243 : }
228 : :
229 : : /* Get the fixed binding slot IX. Creating the vector if CREATE is
230 : : non-zero. If CREATE is < 0, make sure there is at least 1 spare
231 : : slot for an import. (It is an error for CREATE < 0 and the slot to
232 : : already exist.) */
233 : :
234 : : static tree *
235 : 347322497 : get_fixed_binding_slot (tree *slot, tree name, unsigned ix, int create)
236 : : {
237 : 347322497 : gcc_checking_assert (ix <= BINDING_SLOT_PARTITION);
238 : :
239 : : /* An assumption is that the fixed slots all reside in one cluster. */
240 : 347322497 : gcc_checking_assert (BINDING_VECTOR_SLOTS_PER_CLUSTER >= BINDING_SLOTS_FIXED);
241 : :
242 : 347322497 : if (!*slot || TREE_CODE (*slot) != BINDING_VECTOR)
243 : : {
244 : 347087251 : if (ix == BINDING_SLOT_CURRENT)
245 : : /* The current TU can just use slot directly. */
246 : : return slot;
247 : :
248 : 281920 : if (!create)
249 : : return NULL;
250 : :
251 : : /* The partition slot is always needed, in case we have imported
252 : : temploid friends with attachment different from the module we
253 : : imported them from. */
254 : 281920 : bool partition_slot = true;
255 : 281920 : unsigned want = ((BINDING_SLOTS_FIXED + partition_slot + (create < 0)
256 : : + BINDING_VECTOR_SLOTS_PER_CLUSTER - 1)
257 : : / BINDING_VECTOR_SLOTS_PER_CLUSTER);
258 : 281920 : tree new_vec = make_binding_vec (name, want);
259 : 281920 : BINDING_VECTOR_NUM_CLUSTERS (new_vec) = want;
260 : 281920 : binding_cluster *cluster = BINDING_VECTOR_CLUSTER_BASE (new_vec);
261 : :
262 : : /* Initialize the fixed slots. */
263 : 845760 : for (unsigned jx = BINDING_SLOTS_FIXED; jx--;)
264 : : {
265 : 563840 : cluster[0].indices[jx].base = 0;
266 : 563840 : cluster[0].indices[jx].span = 1;
267 : 563840 : cluster[0].slots[jx] = NULL_TREE;
268 : : }
269 : :
270 : 281920 : if (partition_slot)
271 : : {
272 : 281920 : unsigned off = BINDING_SLOT_PARTITION % BINDING_VECTOR_SLOTS_PER_CLUSTER;
273 : 281920 : unsigned ind = BINDING_SLOT_PARTITION / BINDING_VECTOR_SLOTS_PER_CLUSTER;
274 : 281920 : cluster[ind].indices[off].base = 0;
275 : 281920 : cluster[ind].indices[off].span = 1;
276 : 281920 : cluster[ind].slots[off] = NULL_TREE;
277 : : }
278 : :
279 : 281920 : if (tree orig = *slot)
280 : : {
281 : : /* Propagate existing value to current slot. */
282 : :
283 : : /* Propagate global & module entities to the global and
284 : : partition slots. */
285 : 164255 : if (tree type = strip_using_decl (MAYBE_STAT_TYPE (orig)))
286 : 39 : init_global_partition (cluster, type);
287 : :
288 : 372459 : for (ovl_iterator iter (strip_using_decl (MAYBE_STAT_DECL (orig)));
289 : 372459 : iter; ++iter)
290 : : {
291 : 208204 : tree decl = *iter;
292 : :
293 : : /* Internal linkage entities are in deduplicateable. */
294 : 208204 : init_global_partition (cluster, decl);
295 : : }
296 : :
297 : 164255 : if (cluster[0].slots[BINDING_SLOT_GLOBAL]
298 : 164255 : && !(TREE_CODE (orig) == NAMESPACE_DECL
299 : 165675 : && !DECL_NAMESPACE_ALIAS (orig)))
300 : : {
301 : : /* Note that we had some GMF entries. */
302 : 162850 : if (!STAT_HACK_P (orig))
303 : 162801 : orig = stat_hack (orig);
304 : :
305 : 162850 : MODULE_BINDING_GLOBAL_P (orig) = true;
306 : : }
307 : :
308 : 164255 : cluster[0].slots[BINDING_SLOT_CURRENT] = orig;
309 : : }
310 : :
311 : 281920 : *slot = new_vec;
312 : 281920 : }
313 : : else
314 : 235246 : gcc_checking_assert (create >= 0);
315 : :
316 : 517166 : unsigned off = ix % BINDING_VECTOR_SLOTS_PER_CLUSTER;
317 : 517166 : binding_cluster &cluster
318 : 517166 : = BINDING_VECTOR_CLUSTER (*slot, ix / BINDING_VECTOR_SLOTS_PER_CLUSTER);
319 : :
320 : : /* There must always be slots for these indices */
321 : 517166 : gcc_checking_assert (cluster.indices[off].span == 1
322 : : && !cluster.indices[off].base
323 : : && !cluster.slots[off].is_lazy ());
324 : :
325 : 517166 : return reinterpret_cast<tree *> (&cluster.slots[off]);
326 : : }
327 : :
328 : : /* *SLOT is a namespace binding slot. Append a slot for imported
329 : : module IX. */
330 : :
331 : : static binding_slot *
332 : 271248 : append_imported_binding_slot (tree *slot, tree name, unsigned ix)
333 : : {
334 : 271248 : gcc_checking_assert (ix);
335 : :
336 : 271248 : if (!*slot || TREE_CODE (*slot) != BINDING_VECTOR)
337 : : /* Make an initial module vector. */
338 : 263357 : get_fixed_binding_slot (slot, name, BINDING_SLOT_GLOBAL, -1);
339 : 7891 : else if (!BINDING_VECTOR_CLUSTER_LAST (*slot)
340 : 7891 : ->indices[BINDING_VECTOR_SLOTS_PER_CLUSTER - 1].span)
341 : : /* There is space in the last cluster. */;
342 : 6312 : else if (BINDING_VECTOR_NUM_CLUSTERS (*slot)
343 : 6312 : != BINDING_VECTOR_ALLOC_CLUSTERS (*slot))
344 : : /* There is space in the vector. */
345 : 0 : BINDING_VECTOR_NUM_CLUSTERS (*slot)++;
346 : : else
347 : : {
348 : : /* Extend the vector. */
349 : 6312 : unsigned have = BINDING_VECTOR_NUM_CLUSTERS (*slot);
350 : 6312 : unsigned want = (have * 3 + 1) / 2;
351 : :
352 : 6312 : if (want > (unsigned short)~0)
353 : 0 : want = (unsigned short)~0;
354 : :
355 : 6312 : tree new_vec = make_binding_vec (name, want);
356 : 6312 : BINDING_VECTOR_NUM_CLUSTERS (new_vec) = have + 1;
357 : 12624 : BINDING_VECTOR_GLOBAL_DUPS_P (new_vec)
358 : 6312 : = BINDING_VECTOR_GLOBAL_DUPS_P (*slot);
359 : 12624 : BINDING_VECTOR_PARTITION_DUPS_P (new_vec)
360 : 6312 : = BINDING_VECTOR_PARTITION_DUPS_P (*slot);
361 : 12624 : memcpy (BINDING_VECTOR_CLUSTER_BASE (new_vec),
362 : 12624 : BINDING_VECTOR_CLUSTER_BASE (*slot),
363 : 6312 : have * sizeof (binding_cluster));
364 : 6312 : *slot = new_vec;
365 : : }
366 : :
367 : 271248 : binding_cluster *last = BINDING_VECTOR_CLUSTER_LAST (*slot);
368 : 536184 : for (unsigned off = 0; off != BINDING_VECTOR_SLOTS_PER_CLUSTER; off++)
369 : 536184 : if (!last->indices[off].span)
370 : : {
371 : : /* Fill the free slot of the cluster. */
372 : 271248 : last->indices[off].base = ix;
373 : 271248 : last->indices[off].span = 1;
374 : 271248 : last->slots[off] = NULL_TREE;
375 : : /* Check monotonicity. */
376 : 542496 : gcc_checking_assert (last[off ? 0 : -1]
377 : : .indices[off ? off - 1
378 : : : BINDING_VECTOR_SLOTS_PER_CLUSTER - 1]
379 : : .base < ix);
380 : 271248 : return &last->slots[off];
381 : : }
382 : :
383 : 0 : gcc_unreachable ();
384 : : }
385 : :
386 : : /* Add DECL to the list of things declared in binding level B. */
387 : :
388 : : static void
389 : 1129306517 : add_decl_to_level (cp_binding_level *b, tree decl)
390 : : {
391 : 1129306517 : gcc_assert (b->kind != sk_class);
392 : :
393 : : /* Make sure we don't create a circular list. xref_tag can end
394 : : up pushing the same artificial decl more than once. We
395 : : should have already detected that in update_binding. (This isn't a
396 : : complete verification of non-circularity.) */
397 : 1129306517 : gcc_assert (b->names != decl);
398 : :
399 : : /* We build up the list in reverse order, and reverse it later if
400 : : necessary. */
401 : 1129306517 : TREE_CHAIN (decl) = b->names;
402 : 1129306517 : b->names = decl;
403 : :
404 : : /* If appropriate, add decl to separate list of statics. We include
405 : : extern variables because they might turn out to be static later.
406 : : It's OK for this list to contain a few false positives. */
407 : 1129306517 : if (b->kind == sk_namespace
408 : 1129306517 : && ((VAR_P (decl) && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
409 : 329957541 : || (TREE_CODE (decl) == FUNCTION_DECL
410 : 273321999 : && (!TREE_PUBLIC (decl)
411 : 272809532 : || decl_internal_context_p (decl)
412 : 272808443 : || DECL_DECLARED_INLINE_P (decl)))))
413 : 13595253 : vec_safe_push (static_decls, decl);
414 : 1129306517 : }
415 : :
416 : : /* Find the binding for NAME in the local binding level B. */
417 : :
418 : : static cxx_binding *
419 : 772150692 : find_local_binding (cp_binding_level *b, tree name)
420 : : {
421 : 772150692 : if (cxx_binding *binding = IDENTIFIER_BINDING (name))
422 : 0 : for (;; b = b->level_chain)
423 : : {
424 : 2141831 : if (binding->scope == b)
425 : : return binding;
426 : :
427 : : /* Cleanup contours are transparent to the language. */
428 : 2139053 : if (b->kind != sk_cleanup)
429 : : break;
430 : : }
431 : : return NULL;
432 : : }
433 : :
434 : : class name_lookup
435 : : {
436 : : public:
437 : : typedef std::pair<tree, tree> using_pair;
438 : : typedef auto_vec<using_pair, 16> using_queue;
439 : :
440 : : public:
441 : : tree name; /* The identifier being looked for. */
442 : :
443 : : /* Usually we just add things to the VALUE binding, but we record
444 : : (hidden) IMPLICIT_TYPEDEFs on the type binding, which is used for
445 : : using-decl resolution. */
446 : : tree value; /* A (possibly ambiguous) set of things found. */
447 : : tree type; /* A type that has been found. */
448 : :
449 : : LOOK_want want; /* What kind of entity we want. */
450 : :
451 : : bool deduping; /* Full deduping is needed because using declarations
452 : : are in play. */
453 : : vec<tree, va_heap, vl_embed> *scopes;
454 : : name_lookup *previous; /* Previously active lookup. */
455 : :
456 : : protected:
457 : : /* Marked scope stack for outermost name lookup. */
458 : : static vec<tree, va_heap, vl_embed> *shared_scopes;
459 : : /* Currently active lookup. */
460 : : static name_lookup *active;
461 : :
462 : : public:
463 : 1401104012 : name_lookup (tree n, LOOK_want w = LOOK_want::NORMAL)
464 : 1401104012 : : name (n), value (NULL_TREE), type (NULL_TREE),
465 : 1401104012 : want (w),
466 : 1401104012 : deduping (false), scopes (NULL), previous (NULL)
467 : : {
468 : 1401104012 : preserve_state ();
469 : : }
470 : 1401104012 : ~name_lookup ()
471 : : {
472 : 1401104012 : gcc_checking_assert (!deduping);
473 : 1401104012 : restore_state ();
474 : 1401104012 : }
475 : :
476 : : private: /* Uncopyable, unmovable, unassignable. I am a rock. */
477 : : name_lookup (const name_lookup &);
478 : : name_lookup &operator= (const name_lookup &);
479 : :
480 : : public:
481 : : /* Turn on or off deduping mode. */
482 : 1433020449 : void dedup (bool state)
483 : : {
484 : 1433020449 : if (deduping != state)
485 : : {
486 : 88581188 : deduping = state;
487 : 88581188 : lookup_mark (value, state);
488 : : }
489 : 1433020449 : }
490 : :
491 : : protected:
492 : 16099732924 : static bool seen_p (tree scope)
493 : : {
494 : 16099732924 : return LOOKUP_SEEN_P (scope);
495 : : }
496 : 20629055 : static bool found_p (tree scope)
497 : : {
498 : 20629055 : return LOOKUP_FOUND_P (scope);
499 : : }
500 : :
501 : : void mark_seen (tree scope); /* Mark and add to scope vector. */
502 : 310383484 : static void mark_found (tree scope)
503 : : {
504 : 310383484 : gcc_checking_assert (seen_p (scope));
505 : 310383484 : LOOKUP_FOUND_P (scope) = true;
506 : 310383484 : }
507 : 7825923700 : bool see_and_mark (tree scope)
508 : : {
509 : 7825923700 : bool ret = seen_p (scope);
510 : 7825923700 : if (!ret)
511 : 1536793404 : mark_seen (scope);
512 : 7676506167 : return ret;
513 : : }
514 : : bool find_and_mark (tree scope);
515 : :
516 : : private:
517 : : void preserve_state ();
518 : : void restore_state ();
519 : :
520 : : public:
521 : : static tree ambiguous (tree thing, tree current);
522 : : void add_value (tree new_val);
523 : : private:
524 : : void add_overload (tree fns);
525 : : void add_type (tree new_type);
526 : : bool process_binding (tree val_bind, tree type_bind);
527 : : unsigned process_module_binding (tree val_bind, tree type_bind, unsigned);
528 : : /* Look in only namespace. */
529 : : bool search_namespace_only (tree scope);
530 : : /* Look in namespace and its (recursive) inlines. Ignore using
531 : : directives. Return true if something found (inc dups). */
532 : : bool search_namespace (tree scope);
533 : : /* Look in the using directives of namespace + inlines using
534 : : qualified lookup rules. */
535 : : bool search_usings (tree scope);
536 : :
537 : : private:
538 : : void queue_namespace (using_queue& queue, int depth, tree scope);
539 : : void queue_usings (using_queue& queue, int depth, vec<tree, va_gc> *usings);
540 : :
541 : : private:
542 : : void add_fns (tree);
543 : :
544 : : private:
545 : : void adl_expr (tree);
546 : : void adl_type (tree);
547 : : void adl_template_arg (tree);
548 : : void adl_class (tree);
549 : : void adl_enum (tree);
550 : : void adl_bases (tree);
551 : : void adl_class_only (tree);
552 : : void adl_namespace (tree);
553 : : void adl_class_fns (tree);
554 : : void adl_namespace_fns (tree, bitmap);
555 : :
556 : : public:
557 : : /* Search namespace + inlines + maybe usings as qualified lookup. */
558 : : bool search_qualified (tree scope, bool usings = true);
559 : :
560 : : /* Search namespace + inlines + usings as unqualified lookup. */
561 : : bool search_unqualified (tree scope, cp_binding_level *);
562 : :
563 : : /* ADL lookup of ARGS. */
564 : : tree search_adl (tree fns, vec<tree, va_gc> *args);
565 : : };
566 : :
567 : : /* Scope stack shared by all outermost lookups. This avoids us
568 : : allocating and freeing on every single lookup. */
569 : : vec<tree, va_heap, vl_embed> *name_lookup::shared_scopes;
570 : :
571 : : /* Currently active lookup. */
572 : : name_lookup *name_lookup::active;
573 : :
574 : : /* Name lookup is recursive, becase ADL can cause template
575 : : instatiation. This is of course a rare event, so we optimize for
576 : : it not happening. When we discover an active name-lookup, which
577 : : must be an ADL lookup, we need to unmark the marked scopes and also
578 : : unmark the lookup we might have been accumulating. */
579 : :
580 : : void
581 : 1401104012 : name_lookup::preserve_state ()
582 : : {
583 : 1401104012 : previous = active;
584 : 1401104012 : if (previous)
585 : : {
586 : 8899 : unsigned length = vec_safe_length (previous->scopes);
587 : 8899 : vec_safe_reserve (previous->scopes, length * 2);
588 : 82668 : for (unsigned ix = length; ix--;)
589 : : {
590 : 73769 : tree decl = (*previous->scopes)[ix];
591 : :
592 : 73769 : gcc_checking_assert (LOOKUP_SEEN_P (decl));
593 : 73769 : LOOKUP_SEEN_P (decl) = false;
594 : :
595 : : /* Preserve the FOUND_P state on the interrupted lookup's
596 : : stack. */
597 : 73769 : if (LOOKUP_FOUND_P (decl))
598 : : {
599 : 8851 : LOOKUP_FOUND_P (decl) = false;
600 : 8851 : previous->scopes->quick_push (decl);
601 : : }
602 : : }
603 : :
604 : : /* Unmark the outer partial lookup. */
605 : 8899 : if (previous->deduping)
606 : 0 : lookup_mark (previous->value, false);
607 : : }
608 : : else
609 : 1401095113 : scopes = shared_scopes;
610 : 1401104012 : active = this;
611 : 1401104012 : }
612 : :
613 : : /* Restore the marking state of a lookup we interrupted. */
614 : :
615 : : void
616 : 1401104012 : name_lookup::restore_state ()
617 : : {
618 : 1401104012 : gcc_checking_assert (!deduping);
619 : :
620 : : /* Unmark and empty this lookup's scope stack. */
621 : 10478714191 : for (unsigned ix = vec_safe_length (scopes); ix--;)
622 : : {
623 : 7676506167 : tree decl = scopes->pop ();
624 : 7676506167 : gcc_checking_assert (LOOKUP_SEEN_P (decl));
625 : 7676506167 : LOOKUP_SEEN_P (decl) = false;
626 : 7676506167 : LOOKUP_FOUND_P (decl) = false;
627 : : }
628 : :
629 : 1401104012 : active = previous;
630 : 1401104012 : if (previous)
631 : : {
632 : 8899 : free (scopes);
633 : :
634 : 8899 : unsigned length = vec_safe_length (previous->scopes);
635 : 82668 : for (unsigned ix = 0; ix != length; ix++)
636 : : {
637 : 81969 : tree decl = (*previous->scopes)[ix];
638 : 81969 : if (LOOKUP_SEEN_P (decl))
639 : : {
640 : : /* The remainder of the scope stack must be recording
641 : : FOUND_P decls, which we want to pop off. */
642 : 8851 : do
643 : : {
644 : 8851 : tree decl = previous->scopes->pop ();
645 : 8851 : gcc_checking_assert (LOOKUP_SEEN_P (decl)
646 : : && !LOOKUP_FOUND_P (decl));
647 : 8851 : LOOKUP_FOUND_P (decl) = true;
648 : : }
649 : 8851 : while (++ix != length);
650 : : break;
651 : : }
652 : :
653 : 73769 : gcc_checking_assert (!LOOKUP_FOUND_P (decl));
654 : 73769 : LOOKUP_SEEN_P (decl) = true;
655 : : }
656 : :
657 : : /* Remark the outer partial lookup. */
658 : 8899 : if (previous->deduping)
659 : 0 : lookup_mark (previous->value, true);
660 : : }
661 : : else
662 : 1401095113 : shared_scopes = scopes;
663 : 1401104012 : }
664 : :
665 : : void
666 : 7676506167 : name_lookup::mark_seen (tree scope)
667 : : {
668 : 7676506167 : gcc_checking_assert (!seen_p (scope));
669 : 7676506167 : LOOKUP_SEEN_P (scope) = true;
670 : 7676506167 : vec_safe_push (scopes, scope);
671 : 7676506167 : }
672 : :
673 : : bool
674 : 0 : name_lookup::find_and_mark (tree scope)
675 : : {
676 : 0 : bool result = LOOKUP_FOUND_P (scope);
677 : 0 : if (!result)
678 : : {
679 : 0 : LOOKUP_FOUND_P (scope) = true;
680 : 0 : if (!LOOKUP_SEEN_P (scope))
681 : 0 : vec_safe_push (scopes, scope);
682 : : }
683 : :
684 : 0 : return result;
685 : : }
686 : :
687 : : /* THING and CURRENT are ambiguous, concatenate them. */
688 : :
689 : : tree
690 : 451 : name_lookup::ambiguous (tree thing, tree current)
691 : : {
692 : 451 : if (TREE_CODE (current) != TREE_LIST)
693 : : {
694 : 340 : current = build_tree_list (NULL_TREE, current);
695 : 340 : TREE_TYPE (current) = error_mark_node;
696 : : }
697 : 451 : current = tree_cons (NULL_TREE, thing, current);
698 : 451 : TREE_TYPE (current) = error_mark_node;
699 : :
700 : 451 : return current;
701 : : }
702 : :
703 : : /* FNS is a new overload set to add to the exising set. */
704 : :
705 : : void
706 : 482390135 : name_lookup::add_overload (tree fns)
707 : : {
708 : 482390135 : if (!deduping && TREE_CODE (fns) == OVERLOAD)
709 : : {
710 : 342293664 : tree probe = fns;
711 : 342293664 : if (!bool (want & LOOK_want::HIDDEN_FRIEND))
712 : 342225442 : probe = ovl_skip_hidden (probe);
713 : 342293664 : if (probe && TREE_CODE (probe) == OVERLOAD
714 : 684587328 : && OVL_DEDUP_P (probe))
715 : : /* We're about to add something found by multiple paths, so need to
716 : : engage deduping mode. */
717 : 30032866 : dedup (true);
718 : : }
719 : :
720 : 482390135 : value = lookup_maybe_add (fns, value, deduping);
721 : 482390135 : }
722 : :
723 : : /* Add a NEW_VAL, a found value binding into the current value binding. */
724 : :
725 : : void
726 : 1122044164 : name_lookup::add_value (tree new_val)
727 : : {
728 : 1122044164 : if (OVL_P (new_val) && (!value || OVL_P (value)))
729 : 462268406 : add_overload (new_val);
730 : 659775758 : else if (!value)
731 : 659564125 : value = new_val;
732 : 211633 : else if (value == new_val)
733 : : ;
734 : 12528 : else if ((TREE_CODE (value) == TYPE_DECL
735 : 12382 : && TREE_CODE (new_val) == TYPE_DECL
736 : 24910 : && same_type_p (TREE_TYPE (value), TREE_TYPE (new_val))))
737 : : /* Typedefs to the same type. */;
738 : 232 : else if (TREE_CODE (value) == NAMESPACE_DECL
739 : 59 : && TREE_CODE (new_val) == NAMESPACE_DECL
740 : 291 : && ORIGINAL_NAMESPACE (value) == ORIGINAL_NAMESPACE (new_val))
741 : : /* Namespace (possibly aliased) to the same namespace. Locate
742 : : the namespace*/
743 : 30 : value = ORIGINAL_NAMESPACE (value);
744 : : else
745 : : {
746 : : /* Disengage deduping mode. */
747 : 202 : dedup (false);
748 : 202 : value = ambiguous (new_val, value);
749 : : }
750 : 1122044164 : }
751 : :
752 : : /* Add a NEW_TYPE, a found type binding into the current type binding. */
753 : :
754 : : void
755 : 405597 : name_lookup::add_type (tree new_type)
756 : : {
757 : 405597 : if (!type)
758 : 405594 : type = new_type;
759 : 3 : else if (TREE_CODE (type) == TREE_LIST
760 : 3 : || !same_type_p (TREE_TYPE (type), TREE_TYPE (new_type)))
761 : 3 : type = ambiguous (new_type, type);
762 : 405597 : }
763 : :
764 : : /* Process a found binding containing NEW_VAL and NEW_TYPE. Returns
765 : : true if we actually found something noteworthy. Hiddenness has
766 : : already been handled in the caller. */
767 : :
768 : : bool
769 : 1132240053 : name_lookup::process_binding (tree new_val, tree new_type)
770 : : {
771 : : /* Did we really see a type? */
772 : 1132240053 : if (new_type
773 : 1132240053 : && (want & LOOK_want::TYPE_NAMESPACE) == LOOK_want::NAMESPACE)
774 : : new_type = NULL_TREE;
775 : :
776 : 1132240053 : new_val = strip_using_decl (new_val);
777 : 1132240053 : new_type = strip_using_decl (new_type);
778 : :
779 : : /* Do we really see a value? */
780 : 1132240053 : if (new_val)
781 : 1122137216 : switch (TREE_CODE (new_val))
782 : : {
783 : 194255018 : case TEMPLATE_DECL:
784 : : /* If we expect types or namespaces, and not templates,
785 : : or this is not a template class. */
786 : 194255018 : if (bool (want & LOOK_want::TYPE_NAMESPACE)
787 : 194255018 : && !DECL_TYPE_TEMPLATE_P (new_val))
788 : : new_val = NULL_TREE;
789 : : break;
790 : 221272078 : case TYPE_DECL:
791 : 221272078 : if ((want & LOOK_want::TYPE_NAMESPACE) == LOOK_want::NAMESPACE
792 : 221272078 : || (new_type && bool (want & LOOK_want::TYPE)))
793 : : new_val = NULL_TREE;
794 : : break;
795 : 191446951 : case NAMESPACE_DECL:
796 : 191446951 : if ((want & LOOK_want::TYPE_NAMESPACE) == LOOK_want::TYPE)
797 : : new_val = NULL_TREE;
798 : : break;
799 : 515163169 : default:
800 : 515163169 : if (bool (want & LOOK_want::TYPE_NAMESPACE))
801 : : new_val = NULL_TREE;
802 : : }
803 : :
804 : : if (!new_val)
805 : : {
806 : 10237869 : new_val = new_type;
807 : 10237869 : new_type = NULL_TREE;
808 : : }
809 : :
810 : : /* Merge into the lookup */
811 : 10237869 : if (new_val)
812 : 1122044164 : add_value (new_val);
813 : 1132240053 : if (new_type)
814 : 405597 : add_type (new_type);
815 : :
816 : 1132240053 : return new_val != NULL_TREE;
817 : : }
818 : :
819 : : /* If we're importing a module containing this binding, add it to the
820 : : lookup set. The trickiness is with namespaces, we only want to
821 : : find it once. */
822 : :
823 : : unsigned
824 : 33011 : name_lookup::process_module_binding (tree new_val, tree new_type,
825 : : unsigned marker)
826 : : {
827 : : /* Optimize for (re-)finding a public namespace. We only need to
828 : : look once. */
829 : 33011 : if (new_val && !new_type
830 : : && TREE_CODE (new_val) == NAMESPACE_DECL
831 : 30584 : && TREE_PUBLIC (new_val)
832 : 36543 : && !DECL_NAMESPACE_ALIAS (new_val))
833 : : {
834 : 3532 : if (marker & 2)
835 : : return marker;
836 : 2078 : marker |= 2;
837 : : }
838 : :
839 : 31557 : if (new_type || new_val)
840 : 29205 : marker |= process_binding (new_val, new_type);
841 : :
842 : : return marker;
843 : : }
844 : :
845 : : /* Look in exactly namespace SCOPE. */
846 : :
847 : : bool
848 : 7550159676 : name_lookup::search_namespace_only (tree scope)
849 : : {
850 : 7550159676 : bool found = false;
851 : 7550159676 : if (tree *binding = find_namespace_slot (scope, name))
852 : : {
853 : 1132233306 : tree val = *binding;
854 : 1132233306 : if (TREE_CODE (val) == BINDING_VECTOR)
855 : : {
856 : : /* I presume the binding list is going to be sparser than
857 : : the import bitmap. Hence iterate over the former
858 : : checking for bits set in the bitmap. */
859 : 22458 : bitmap imports = get_import_bitmap ();
860 : 22458 : binding_cluster *cluster = BINDING_VECTOR_CLUSTER_BASE (val);
861 : 22458 : int marker = 0;
862 : 22458 : int dup_detect = 0;
863 : :
864 : 22458 : if (tree bind = cluster->slots[BINDING_SLOT_CURRENT])
865 : : {
866 : 10982 : if (!deduping)
867 : : {
868 : 9530 : if (named_module_purview_p ())
869 : : {
870 : 255 : dup_detect |= 2;
871 : :
872 : 255 : if (STAT_HACK_P (bind) && MODULE_BINDING_GLOBAL_P (bind))
873 : : dup_detect |= 1;
874 : : }
875 : : else
876 : : dup_detect |= 1;
877 : : }
878 : 10982 : tree type = NULL_TREE;
879 : 10982 : tree value = bind;
880 : :
881 : 10982 : if (STAT_HACK_P (bind))
882 : : {
883 : 8834 : type = STAT_TYPE (bind);
884 : 8834 : value = STAT_DECL (bind);
885 : :
886 : 8834 : if (!bool (want & LOOK_want::HIDDEN_FRIEND))
887 : : {
888 : 8803 : if (STAT_TYPE_HIDDEN_P (bind))
889 : 0 : type = NULL_TREE;
890 : 8803 : if (STAT_DECL_HIDDEN_P (bind))
891 : : value = NULL_TREE;
892 : : else
893 : 8803 : value = ovl_skip_hidden (value);
894 : : }
895 : : }
896 : 2148 : else if (!bool (want & LOOK_want::HIDDEN_FRIEND))
897 : 2148 : value = ovl_skip_hidden (value);
898 : :
899 : 10982 : marker = process_module_binding (value, type, marker);
900 : : }
901 : :
902 : : /* Scan the imported bindings. */
903 : 22458 : unsigned ix = BINDING_VECTOR_NUM_CLUSTERS (val);
904 : 22458 : if (BINDING_VECTOR_SLOTS_PER_CLUSTER == BINDING_SLOTS_FIXED)
905 : : {
906 : 22458 : ix--;
907 : 22458 : cluster++;
908 : : }
909 : :
910 : : /* Do this in forward order, so we load modules in an order
911 : : the user expects. */
912 : 45573 : for (; ix--; cluster++)
913 : 69345 : for (unsigned jx = 0; jx != BINDING_VECTOR_SLOTS_PER_CLUSTER; jx++)
914 : : {
915 : : /* Are we importing this module? */
916 : 46230 : if (unsigned base = cluster->indices[jx].base)
917 : 22475 : if (unsigned span = cluster->indices[jx].span)
918 : 22478 : do
919 : 22478 : if (bool (want & LOOK_want::ANY_REACHABLE)
920 : 22478 : || bitmap_bit_p (imports, base))
921 : 22029 : goto found;
922 : 449 : while (++base, --span);
923 : 24201 : continue;
924 : :
925 : 22029 : found:;
926 : : /* Is it loaded? */
927 : 22029 : if (cluster->slots[jx].is_lazy ())
928 : : {
929 : 1994 : gcc_assert (cluster->indices[jx].span == 1);
930 : 1994 : lazy_load_binding (cluster->indices[jx].base,
931 : : scope, name, &cluster->slots[jx]);
932 : : }
933 : 22029 : tree bind = cluster->slots[jx];
934 : 22029 : if (!bind)
935 : : /* Load errors could mean there's nothing here. */
936 : 0 : continue;
937 : :
938 : : /* Extract what we can see from here. If there's no
939 : : stat_hack, then everything was exported. */
940 : 22029 : tree type = NULL_TREE;
941 : :
942 : : /* If STAT_HACK_P is false, everything is visible, and
943 : : there's no duplication possibilities. */
944 : 22029 : if (STAT_HACK_P (bind))
945 : : {
946 : 14709 : if (!deduping)
947 : : {
948 : : /* Do we need to engage deduplication? */
949 : 13128 : int dup = 0;
950 : 13128 : if (MODULE_BINDING_GLOBAL_P (bind))
951 : 11448 : dup |= 1;
952 : 13128 : if (MODULE_BINDING_PARTITION_P (bind))
953 : 1248 : dup |= 2;
954 : 13128 : if (unsigned hit = dup_detect & dup)
955 : : {
956 : 7091 : if ((hit & 1 && BINDING_VECTOR_GLOBAL_DUPS_P (val))
957 : 7647 : || (hit & 2
958 : 210 : && BINDING_VECTOR_PARTITION_DUPS_P (val)))
959 : 6865 : dedup (true);
960 : : }
961 : 13128 : dup_detect |= dup;
962 : : }
963 : :
964 : 14709 : if (bool (want & LOOK_want::ANY_REACHABLE))
965 : : {
966 : 84 : type = STAT_TYPE (bind);
967 : 84 : bind = STAT_DECL (bind);
968 : : }
969 : : else
970 : : {
971 : 14625 : if (STAT_TYPE_VISIBLE_P (bind))
972 : 1305 : type = STAT_TYPE (bind);
973 : 14625 : bind = STAT_VISIBLE (bind);
974 : : }
975 : : }
976 : :
977 : : /* And process it. */
978 : 22029 : marker = process_module_binding (bind, type, marker);
979 : 24201 : }
980 : 22458 : found |= marker & 1;
981 : : }
982 : : else
983 : : {
984 : : /* Only a current module binding, visible from the current module. */
985 : 1132210848 : tree bind = *binding;
986 : 1132210848 : tree value = bind, type = NULL_TREE;
987 : :
988 : 1132210848 : if (STAT_HACK_P (bind))
989 : : {
990 : 448143 : type = STAT_TYPE (bind);
991 : 448143 : value = STAT_DECL (bind);
992 : :
993 : 448143 : if (!bool (want & LOOK_want::HIDDEN_FRIEND))
994 : : {
995 : 447914 : if (STAT_TYPE_HIDDEN_P (bind))
996 : 3 : type = NULL_TREE;
997 : 447914 : if (STAT_DECL_HIDDEN_P (bind))
998 : : value = NULL_TREE;
999 : : else
1000 : 447505 : value = ovl_skip_hidden (value);
1001 : : }
1002 : : }
1003 : 1131762705 : else if (!bool (want & LOOK_want::HIDDEN_FRIEND))
1004 : 1131306092 : value = ovl_skip_hidden (value);
1005 : :
1006 : 1132210848 : found |= process_binding (value, type);
1007 : : }
1008 : : }
1009 : :
1010 : 7550159676 : return found;
1011 : : }
1012 : :
1013 : : /* Conditionally look in namespace SCOPE and inline children. */
1014 : :
1015 : : bool
1016 : 1415751760 : name_lookup::search_namespace (tree scope)
1017 : : {
1018 : 1415751760 : if (see_and_mark (scope))
1019 : : /* We've visited this scope before. Return what we found then. */
1020 : 0 : return found_p (scope);
1021 : :
1022 : : /* Look in exactly namespace. */
1023 : 1415751760 : bool found = search_namespace_only (scope);
1024 : :
1025 : : /* Don't look into inline children, if we're looking for an
1026 : : anonymous name -- it must be in the current scope, if anywhere. */
1027 : 1415751760 : if (name)
1028 : : /* Recursively look in its inline children. */
1029 : 1415750088 : if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
1030 : 1537131304 : for (unsigned ix = inlinees->length (); ix--;)
1031 : 1128832187 : found |= search_namespace ((*inlinees)[ix]);
1032 : :
1033 : 1415751760 : if (found)
1034 : 294955940 : mark_found (scope);
1035 : :
1036 : : return found;
1037 : : }
1038 : :
1039 : : /* Recursively follow using directives of SCOPE & its inline children.
1040 : : Such following is essentially a flood-fill algorithm. */
1041 : :
1042 : : bool
1043 : 1918990 : name_lookup::search_usings (tree scope)
1044 : : {
1045 : : /* We do not check seen_p here, as that was already set during the
1046 : : namespace_only walk. */
1047 : 1918990 : if (found_p (scope))
1048 : : return true;
1049 : :
1050 : 1918990 : bool found = false;
1051 : 1918990 : if (vec<tree, va_gc> *usings = NAMESPACE_LEVEL (scope)->using_directives)
1052 : 397808 : for (unsigned ix = usings->length (); ix--;)
1053 : 199084 : found |= search_qualified ((*usings)[ix], true);
1054 : :
1055 : : /* Look in its inline children. */
1056 : 1918990 : if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
1057 : 1066618 : for (unsigned ix = inlinees->length (); ix--;)
1058 : 609717 : found |= search_usings ((*inlinees)[ix]);
1059 : :
1060 : 1918990 : if (found)
1061 : 1404 : mark_found (scope);
1062 : :
1063 : : return found;
1064 : : }
1065 : :
1066 : : /* Qualified namespace lookup in SCOPE.
1067 : : 1) Look in SCOPE (+inlines). If found, we're done.
1068 : : 2) Otherwise, if USINGS is true,
1069 : : recurse for every using directive of SCOPE (+inlines).
1070 : :
1071 : : Trickiness is (a) loops and (b) multiple paths to same namespace.
1072 : : In both cases we want to not repeat any lookups, and know whether
1073 : : to stop the caller's step #2. Do this via the FOUND_P marker. */
1074 : :
1075 : : bool
1076 : 286919573 : name_lookup::search_qualified (tree scope, bool usings)
1077 : : {
1078 : 286919573 : bool found = false;
1079 : :
1080 : 286919573 : if (seen_p (scope))
1081 : 0 : found = found_p (scope);
1082 : : else
1083 : : {
1084 : 286919573 : found = search_namespace (scope);
1085 : 286919573 : if (!found && usings)
1086 : 1309273 : found = search_usings (scope);
1087 : : }
1088 : :
1089 : 286919573 : dedup (false);
1090 : :
1091 : 286919573 : return found;
1092 : : }
1093 : :
1094 : : /* Add SCOPE to the unqualified search queue, recursively add its
1095 : : inlines and those via using directives. */
1096 : :
1097 : : void
1098 : 6202901862 : name_lookup::queue_namespace (using_queue& queue, int depth, tree scope)
1099 : : {
1100 : 6202901862 : if (see_and_mark (scope))
1101 : 6202901862 : return;
1102 : :
1103 : : /* Record it. */
1104 : : tree common = scope;
1105 : 12429419599 : while (SCOPE_DEPTH (common) > depth)
1106 : 6289706836 : common = CP_DECL_CONTEXT (common);
1107 : 6139712763 : queue.safe_push (using_pair (common, scope));
1108 : :
1109 : : /* Queue its inline children. */
1110 : 6139712763 : if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
1111 : 6120036990 : for (unsigned ix = inlinees->length (); ix--;)
1112 : 4500361136 : queue_namespace (queue, depth, (*inlinees)[ix]);
1113 : :
1114 : : /* Queue its using targets. */
1115 : 6139712763 : queue_usings (queue, depth, NAMESPACE_LEVEL (scope)->using_directives);
1116 : : }
1117 : :
1118 : : /* Add the namespaces in USINGS to the unqualified search queue. */
1119 : :
1120 : : void
1121 : 9579067874 : name_lookup::queue_usings (using_queue& queue, int depth, vec<tree, va_gc> *usings)
1122 : : {
1123 : 9579067874 : if (usings)
1124 : 32330542 : for (unsigned ix = usings->length (); ix--;)
1125 : 16351032 : queue_namespace (queue, depth, (*usings)[ix]);
1126 : 9579067874 : }
1127 : :
1128 : : /* Unqualified namespace lookup in SCOPE.
1129 : : 1) add scope+inlins to worklist.
1130 : : 2) recursively add target of every using directive
1131 : : 3) for each worklist item where SCOPE is common ancestor, search it
1132 : : 4) if nothing find, scope=parent, goto 1. */
1133 : :
1134 : : bool
1135 : 1079650555 : name_lookup::search_unqualified (tree scope, cp_binding_level *level)
1136 : : {
1137 : 1079650555 : using_queue queue;
1138 : 1079650555 : bool found = false;
1139 : :
1140 : : /* Queue local using-directives. */
1141 : 4519005666 : for (; level->kind != sk_namespace; level = level->level_chain)
1142 : 3439355111 : queue_usings (queue, SCOPE_DEPTH (scope), level->using_directives);
1143 : :
1144 : 3364891047 : for (; !found; scope = CP_DECL_CONTEXT (scope))
1145 : : {
1146 : 1686189694 : gcc_assert (!DECL_NAMESPACE_ALIAS (scope));
1147 : 1686189694 : int depth = SCOPE_DEPTH (scope);
1148 : :
1149 : : /* Queue namespaces reachable from SCOPE. */
1150 : 1686189694 : queue_namespace (queue, depth, scope);
1151 : :
1152 : : /* Search every queued namespace where SCOPE is the common
1153 : : ancestor. Adjust the others. */
1154 : 1686189694 : unsigned ix = 0;
1155 : 1697785735 : do
1156 : : {
1157 : 1697785735 : using_pair &pair = queue[ix];
1158 : 7845039315 : while (pair.first == scope)
1159 : : {
1160 : 6134407916 : found |= search_namespace_only (pair.second);
1161 : 6134407916 : pair = queue.pop ();
1162 : 6134407916 : if (ix == queue.length ())
1163 : 1684940071 : goto done;
1164 : : }
1165 : : /* The depth is the same as SCOPE, find the parent scope. */
1166 : 12845664 : if (SCOPE_DEPTH (pair.first) == depth)
1167 : 12841659 : pair.first = CP_DECL_CONTEXT (pair.first);
1168 : 12845664 : ix++;
1169 : : }
1170 : 25691328 : while (ix < queue.length ());
1171 : 1249623 : done:;
1172 : 1686189694 : if (scope == global_namespace)
1173 : : break;
1174 : :
1175 : : /* If looking for hidden friends, we only look in the innermost
1176 : : namespace scope. [namespace.memdef]/3 If a friend
1177 : : declaration in a non-local class first declares a class,
1178 : : function, class template or function template the friend is a
1179 : : member of the innermost enclosing namespace. See also
1180 : : [basic.lookup.unqual]/7 */
1181 : 1142982777 : if (bool (want & LOOK_want::HIDDEN_FRIEND))
1182 : : break;
1183 : : }
1184 : :
1185 : 1079650555 : dedup (false);
1186 : :
1187 : 1079650555 : return found;
1188 : 1079650555 : }
1189 : :
1190 : : /* FNS is a value binding. If it is a (set of overloaded) functions,
1191 : : add them into the current value. */
1192 : :
1193 : : void
1194 : 21821578 : name_lookup::add_fns (tree fns)
1195 : : {
1196 : 21821578 : if (!fns)
1197 : : return;
1198 : 20126775 : else if (TREE_CODE (fns) == OVERLOAD)
1199 : : {
1200 : 12880831 : if (TREE_TYPE (fns) != unknown_type_node)
1201 : 86365 : fns = OVL_FUNCTION (fns);
1202 : : }
1203 : 7245944 : else if (!DECL_DECLARES_FUNCTION_P (fns))
1204 : : return;
1205 : :
1206 : 20121729 : add_overload (fns);
1207 : : }
1208 : :
1209 : : /* Add the overloaded fns of SCOPE. */
1210 : :
1211 : : void
1212 : 91339361 : name_lookup::adl_namespace_fns (tree scope, bitmap imports)
1213 : : {
1214 : 91339361 : if (tree *binding = find_namespace_slot (scope, name))
1215 : : {
1216 : 16707001 : tree val = *binding;
1217 : 16707001 : if (TREE_CODE (val) != BINDING_VECTOR)
1218 : 16696803 : add_fns (ovl_skip_hidden (MAYBE_STAT_DECL (val)));
1219 : : else
1220 : : {
1221 : : /* I presume the binding list is going to be sparser than
1222 : : the import bitmap. Hence iterate over the former
1223 : : checking for bits set in the bitmap. */
1224 : 10198 : binding_cluster *cluster = BINDING_VECTOR_CLUSTER_BASE (val);
1225 : 10198 : int dup_detect = 0;
1226 : :
1227 : 10198 : if (tree bind = cluster->slots[BINDING_SLOT_CURRENT])
1228 : : {
1229 : : /* The current TU's bindings must be visible, we don't
1230 : : need to check the bitmaps. */
1231 : :
1232 : 7526 : if (!deduping)
1233 : : {
1234 : 2519 : if (named_module_purview_p ())
1235 : : {
1236 : 6 : dup_detect |= 2;
1237 : :
1238 : 6 : if (STAT_HACK_P (bind) && MODULE_BINDING_GLOBAL_P (bind))
1239 : : dup_detect |= 1;
1240 : : }
1241 : : else
1242 : : dup_detect |= 1;
1243 : : }
1244 : :
1245 : 7526 : add_fns (ovl_skip_hidden (MAYBE_STAT_DECL (bind)));
1246 : : }
1247 : :
1248 : : /* Scan the imported bindings. */
1249 : 10198 : unsigned ix = BINDING_VECTOR_NUM_CLUSTERS (val);
1250 : 10198 : if (BINDING_VECTOR_SLOTS_PER_CLUSTER == BINDING_SLOTS_FIXED)
1251 : : {
1252 : 10198 : ix--;
1253 : 10198 : cluster++;
1254 : : }
1255 : :
1256 : : /* Do this in forward order, so we load modules in an order
1257 : : the user expects. */
1258 : 20405 : for (; ix--; cluster++)
1259 : 30621 : for (unsigned jx = 0; jx != BINDING_VECTOR_SLOTS_PER_CLUSTER; jx++)
1260 : : {
1261 : : /* Functions are never on merged slots. */
1262 : 20414 : if (!cluster->indices[jx].base
1263 : 9651 : || cluster->indices[jx].span != 1)
1264 : 10763 : continue;
1265 : :
1266 : : /* Is this slot visible? */
1267 : 9651 : if (!bitmap_bit_p (imports, cluster->indices[jx].base))
1268 : 0 : continue;
1269 : :
1270 : : /* Is it loaded. */
1271 : 9651 : if (cluster->slots[jx].is_lazy ())
1272 : 12 : lazy_load_binding (cluster->indices[jx].base,
1273 : : scope, name, &cluster->slots[jx]);
1274 : :
1275 : 9651 : tree bind = cluster->slots[jx];
1276 : 9651 : if (!bind)
1277 : : /* Load errors could mean there's nothing here. */
1278 : 0 : continue;
1279 : :
1280 : 9651 : if (STAT_HACK_P (bind))
1281 : : {
1282 : 9597 : if (!deduping)
1283 : : {
1284 : : /* Do we need to engage deduplication? */
1285 : 3740 : int dup = 0;
1286 : 3740 : if (MODULE_BINDING_GLOBAL_P (bind))
1287 : 3719 : dup |= 1;
1288 : 3740 : if (MODULE_BINDING_PARTITION_P (bind))
1289 : 12 : dup |= 2;
1290 : 3740 : if (unsigned hit = dup_detect & dup)
1291 : 2177 : if ((hit & 1 && BINDING_VECTOR_GLOBAL_DUPS_P (val))
1292 : 2247 : || (hit & 2
1293 : 6 : && BINDING_VECTOR_PARTITION_DUPS_P (val)))
1294 : 2113 : dedup (true);
1295 : 3740 : dup_detect |= dup;
1296 : : }
1297 : :
1298 : 9597 : bind = STAT_VISIBLE (bind);
1299 : : }
1300 : :
1301 : 9651 : add_fns (bind);
1302 : : }
1303 : : }
1304 : : }
1305 : 91339361 : }
1306 : :
1307 : : /* Add the hidden friends of SCOPE. */
1308 : :
1309 : : void
1310 : 21003182 : name_lookup::adl_class_fns (tree type)
1311 : : {
1312 : : /* Add friends. */
1313 : 21003182 : for (tree list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type));
1314 : 50542738 : list; list = TREE_CHAIN (list))
1315 : 29539556 : if (name == FRIEND_NAME (list))
1316 : : {
1317 : 2821622 : tree context = NULL_TREE; /* Lazily computed. */
1318 : 7953212 : for (tree friends = FRIEND_DECLS (list); friends;
1319 : 5131590 : friends = TREE_CHAIN (friends))
1320 : : {
1321 : 5131590 : tree fn = TREE_VALUE (friends);
1322 : :
1323 : : /* Only interested in global functions with potentially hidden
1324 : : (i.e. unqualified) declarations. */
1325 : 5131590 : if (!context)
1326 : 2821622 : context = decl_namespace_context (type);
1327 : 5131590 : if (CP_DECL_CONTEXT (fn) != context)
1328 : 21027 : continue;
1329 : :
1330 : 5110563 : dedup (true);
1331 : :
1332 : : /* Template specializations are never found by name lookup.
1333 : : (Templates themselves can be found, but not template
1334 : : specializations.) */
1335 : 5110563 : if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
1336 : 2965 : continue;
1337 : :
1338 : 5107598 : add_fns (fn);
1339 : : }
1340 : : }
1341 : 21003182 : }
1342 : :
1343 : : /* Find the containing non-inlined namespace, add it and all its
1344 : : inlinees. */
1345 : :
1346 : : void
1347 : 99810513 : name_lookup::adl_namespace (tree scope)
1348 : : {
1349 : 170965326 : if (see_and_mark (scope))
1350 : : return;
1351 : :
1352 : : /* Look down into inline namespaces. */
1353 : 91339361 : if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
1354 : 96216222 : for (unsigned ix = inlinees->length (); ix--;)
1355 : 71154813 : adl_namespace ((*inlinees)[ix]);
1356 : :
1357 : 91339361 : if (DECL_NAMESPACE_INLINE_P (scope))
1358 : : /* Mark parent. */
1359 : 71154813 : adl_namespace (CP_DECL_CONTEXT (scope));
1360 : : }
1361 : :
1362 : : /* Adds the class and its friends to the lookup structure. */
1363 : :
1364 : : void
1365 : 21109152 : name_lookup::adl_class_only (tree type)
1366 : : {
1367 : : /* Backend-built structures, such as __builtin_va_list, aren't
1368 : : affected by all this. */
1369 : 21109152 : if (!CLASS_TYPE_P (type))
1370 : : return;
1371 : :
1372 : 21109152 : type = TYPE_MAIN_VARIANT (type);
1373 : :
1374 : 21109152 : if (see_and_mark (type))
1375 : : return;
1376 : :
1377 : 21003182 : tree context = decl_namespace_context (type);
1378 : 21003182 : adl_namespace (context);
1379 : : }
1380 : :
1381 : : /* Adds the class and its bases to the lookup structure.
1382 : : Returns true on error. */
1383 : :
1384 : : void
1385 : 19292980 : name_lookup::adl_bases (tree type)
1386 : : {
1387 : 19292980 : adl_class_only (type);
1388 : :
1389 : : /* Process baseclasses. */
1390 : 19292980 : if (tree binfo = TYPE_BINFO (type))
1391 : : {
1392 : : tree base_binfo;
1393 : : int i;
1394 : :
1395 : 23128409 : for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
1396 : 3866840 : adl_bases (BINFO_TYPE (base_binfo));
1397 : : }
1398 : 19292980 : }
1399 : :
1400 : : /* Adds everything associated with a class argument type to the lookup
1401 : : structure.
1402 : :
1403 : : If T is a class type (including unions), its associated classes are: the
1404 : : class itself; the class of which it is a member, if any; and its direct
1405 : : and indirect base classes. Its associated namespaces are the namespaces
1406 : : of which its associated classes are members. Furthermore, if T is a
1407 : : class template specialization, its associated namespaces and classes
1408 : : also include: the namespaces and classes associated with the types of
1409 : : the template arguments provided for template type parameters (excluding
1410 : : template template parameters); the namespaces of which any template
1411 : : template arguments are members; and the classes of which any member
1412 : : templates used as template template arguments are members. [ Note:
1413 : : non-type template arguments do not contribute to the set of associated
1414 : : namespaces. --end note] */
1415 : :
1416 : : void
1417 : 18791885 : name_lookup::adl_class (tree type)
1418 : : {
1419 : : /* Backend build structures, such as __builtin_va_list, aren't
1420 : : affected by all this. */
1421 : 18791885 : if (!CLASS_TYPE_P (type))
1422 : : return;
1423 : :
1424 : 18710065 : type = TYPE_MAIN_VARIANT (type);
1425 : :
1426 : : /* We don't set found here because we have to have set seen first,
1427 : : which is done in the adl_bases walk. */
1428 : 18710065 : if (found_p (type))
1429 : : return;
1430 : :
1431 : 15426140 : complete_type (type);
1432 : 15426140 : adl_bases (type);
1433 : 15426140 : mark_found (type);
1434 : :
1435 : 15426140 : if (TYPE_CLASS_SCOPE_P (type))
1436 : 766847 : adl_class_only (TYPE_CONTEXT (type));
1437 : :
1438 : : /* Process template arguments. */
1439 : 15426140 : if (CLASSTYPE_TEMPLATE_INFO (type)
1440 : 15426140 : && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
1441 : : {
1442 : 8410572 : tree list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
1443 : 23826497 : for (int i = 0; i < TREE_VEC_LENGTH (list); ++i)
1444 : 15415925 : adl_template_arg (TREE_VEC_ELT (list, i));
1445 : : }
1446 : : }
1447 : :
1448 : : void
1449 : 15195600 : name_lookup::adl_enum (tree type)
1450 : : {
1451 : 15195600 : type = TYPE_MAIN_VARIANT (type);
1452 : 15195600 : if (see_and_mark (type))
1453 : : return;
1454 : :
1455 : 8699101 : if (TYPE_CLASS_SCOPE_P (type))
1456 : 1049319 : adl_class_only (TYPE_CONTEXT (type));
1457 : : else
1458 : 7649782 : adl_namespace (decl_namespace_context (type));
1459 : : }
1460 : :
1461 : : void
1462 : 59403480 : name_lookup::adl_expr (tree expr)
1463 : : {
1464 : 59403480 : if (!expr)
1465 : : return;
1466 : :
1467 : 59403480 : gcc_assert (!TYPE_P (expr));
1468 : :
1469 : 59403480 : if (TREE_TYPE (expr) != unknown_type_node)
1470 : : {
1471 : 59395276 : adl_type (unlowered_expr_type (expr));
1472 : 59395276 : return;
1473 : : }
1474 : :
1475 : 8204 : if (TREE_CODE (expr) == ADDR_EXPR)
1476 : 494 : expr = TREE_OPERAND (expr, 0);
1477 : 8204 : if (TREE_CODE (expr) == COMPONENT_REF
1478 : 8204 : || TREE_CODE (expr) == OFFSET_REF)
1479 : 456 : expr = TREE_OPERAND (expr, 1);
1480 : 8204 : expr = MAYBE_BASELINK_FUNCTIONS (expr);
1481 : :
1482 : 8204 : if (OVL_P (expr))
1483 : 15914 : for (lkp_iterator iter (expr); iter; ++iter)
1484 : 8111 : adl_type (TREE_TYPE (*iter));
1485 : 401 : else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
1486 : : {
1487 : : /* The working paper doesn't currently say how to handle
1488 : : template-id arguments. The sensible thing would seem to be
1489 : : to handle the list of template candidates like a normal
1490 : : overload set, and handle the template arguments like we do
1491 : : for class template specializations. */
1492 : :
1493 : : /* First the templates. */
1494 : 401 : adl_expr (TREE_OPERAND (expr, 0));
1495 : :
1496 : : /* Now the arguments. */
1497 : 401 : if (tree args = TREE_OPERAND (expr, 1))
1498 : 808 : for (int ix = TREE_VEC_LENGTH (args); ix--;)
1499 : 407 : adl_template_arg (TREE_VEC_ELT (args, ix));
1500 : : }
1501 : : }
1502 : :
1503 : : void
1504 : 72500752 : name_lookup::adl_type (tree type)
1505 : : {
1506 : 80460088 : if (!type)
1507 : : return;
1508 : :
1509 : 80460088 : if (TYPE_PTRDATAMEM_P (type))
1510 : : {
1511 : : /* Pointer to member: associate class type and value type. */
1512 : 1097 : adl_type (TYPE_PTRMEM_CLASS_TYPE (type));
1513 : 1097 : adl_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
1514 : 1097 : return;
1515 : : }
1516 : :
1517 : 80458991 : switch (TREE_CODE (type))
1518 : : {
1519 : 17564142 : case RECORD_TYPE:
1520 : 17564142 : if (TYPE_PTRMEMFUNC_P (type))
1521 : : {
1522 : 47541 : adl_type (TYPE_PTRMEMFUNC_FN_TYPE (type));
1523 : 47541 : return;
1524 : : }
1525 : : /* FALLTHRU */
1526 : 18791885 : case UNION_TYPE:
1527 : 18791885 : adl_class (type);
1528 : 18791885 : return;
1529 : :
1530 : 123367 : case METHOD_TYPE:
1531 : : /* The basetype is referenced in the first arg type, so just
1532 : : fall through. */
1533 : 123367 : case FUNCTION_TYPE:
1534 : : /* Associate the parameter types. */
1535 : 566059 : for (tree args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
1536 : 442692 : adl_type (TREE_VALUE (args));
1537 : : /* FALLTHROUGH */
1538 : :
1539 : 7910695 : case POINTER_TYPE:
1540 : 7910695 : case REFERENCE_TYPE:
1541 : 7910695 : case ARRAY_TYPE:
1542 : 7910695 : adl_type (TREE_TYPE (type));
1543 : 7910695 : return;
1544 : :
1545 : 15195600 : case ENUMERAL_TYPE:
1546 : 15195600 : adl_enum (type);
1547 : 15195600 : return;
1548 : :
1549 : 654 : case LANG_TYPE:
1550 : 654 : gcc_assert (type == unknown_type_node
1551 : : || type == init_list_type_node);
1552 : : return;
1553 : :
1554 : 3 : case TYPE_PACK_EXPANSION:
1555 : 3 : adl_type (PACK_EXPANSION_PATTERN (type));
1556 : 3 : return;
1557 : :
1558 : : default:
1559 : : break;
1560 : : }
1561 : : }
1562 : :
1563 : : /* Adds everything associated with a template argument to the lookup
1564 : : structure. */
1565 : :
1566 : : void
1567 : 15465908 : name_lookup::adl_template_arg (tree arg)
1568 : : {
1569 : : /* [basic.lookup.koenig]
1570 : :
1571 : : If T is a template-id, its associated namespaces and classes are
1572 : : ... the namespaces and classes associated with the types of the
1573 : : template arguments provided for template type parameters
1574 : : (excluding template template parameters); the namespaces in which
1575 : : any template template arguments are defined; and the classes in
1576 : : which any member templates used as template template arguments
1577 : : are defined. [Note: non-type template arguments do not
1578 : : contribute to the set of associated namespaces. ] */
1579 : :
1580 : : /* Consider first template template arguments. */
1581 : 15465908 : if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
1582 : 15465908 : || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
1583 : : ;
1584 : 15465908 : else if (TREE_CODE (arg) == TEMPLATE_DECL)
1585 : : {
1586 : 2742 : tree ctx = CP_DECL_CONTEXT (arg);
1587 : :
1588 : : /* It's not a member template. */
1589 : 2742 : if (TREE_CODE (ctx) == NAMESPACE_DECL)
1590 : 2736 : adl_namespace (ctx);
1591 : : /* Otherwise, it must be member template. */
1592 : : else
1593 : 6 : adl_class_only (ctx);
1594 : : }
1595 : : /* It's an argument pack; handle it recursively. */
1596 : 15463166 : else if (ARGUMENT_PACK_P (arg))
1597 : : {
1598 : 14057 : tree args = ARGUMENT_PACK_ARGS (arg);
1599 : 14057 : int i, len = TREE_VEC_LENGTH (args);
1600 : 63633 : for (i = 0; i < len; ++i)
1601 : 49576 : adl_template_arg (TREE_VEC_ELT (args, i));
1602 : : }
1603 : : /* It's not a template template argument, but it is a type template
1604 : : argument. */
1605 : 15449109 : else if (TYPE_P (arg))
1606 : 12653496 : adl_type (arg);
1607 : 15465908 : }
1608 : :
1609 : : /* Perform ADL lookup. FNS is the existing lookup result and ARGS are
1610 : : the call arguments. */
1611 : :
1612 : : tree
1613 : 32133817 : name_lookup::search_adl (tree fns, vec<tree, va_gc> *args)
1614 : : {
1615 : 32133817 : gcc_checking_assert (!vec_safe_length (scopes));
1616 : :
1617 : : /* Gather each associated entity onto the lookup's scope list. */
1618 : 32133817 : unsigned ix;
1619 : 32133817 : tree arg;
1620 : :
1621 : 91536976 : FOR_EACH_VEC_ELT_REVERSE (*args, ix, arg)
1622 : : /* OMP reduction operators put an ADL-significant type as the
1623 : : first arg. */
1624 : 59403159 : if (TYPE_P (arg))
1625 : 80 : adl_type (arg);
1626 : : else
1627 : 59403079 : adl_expr (arg);
1628 : :
1629 : 32133817 : if (vec_safe_length (scopes))
1630 : : {
1631 : : /* Now do the lookups. */
1632 : 17718327 : value = fns;
1633 : 17718327 : if (fns)
1634 : 13579385 : dedup (true);
1635 : :
1636 : : /* INST_PATH will be NULL, if this is /not/ 2nd-phase ADL. */
1637 : 17718327 : bitmap inst_path = NULL;
1638 : : /* VISIBLE is the regular import bitmap. */
1639 : 17718327 : bitmap visible = visible_instantiation_path (&inst_path);
1640 : :
1641 : 138759971 : for (unsigned ix = scopes->length (); ix--;)
1642 : : {
1643 : 121041644 : tree scope = (*scopes)[ix];
1644 : 121041644 : if (TREE_CODE (scope) == NAMESPACE_DECL)
1645 : 91339361 : adl_namespace_fns (scope, visible);
1646 : : else
1647 : : {
1648 : 29702283 : if (RECORD_OR_UNION_TYPE_P (scope))
1649 : 21003182 : adl_class_fns (scope);
1650 : :
1651 : : /* During 2nd phase ADL: Any exported declaration D in N
1652 : : declared within the purview of a named module M
1653 : : (10.2) is visible if there is an associated entity
1654 : : attached to M with the same innermost enclosing
1655 : : non-inline namespace as D.
1656 : : [basic.lookup.argdep]/4.4 */
1657 : :
1658 : 29702283 : if (!inst_path)
1659 : : /* Not 2nd phase. */
1660 : 29630356 : continue;
1661 : :
1662 : 71927 : tree ctx = CP_DECL_CONTEXT (TYPE_NAME (scope));
1663 : 71927 : if (TREE_CODE (ctx) != NAMESPACE_DECL)
1664 : : /* Not namespace-scope class. */
1665 : 3680 : continue;
1666 : :
1667 : 68247 : tree origin = get_originating_module_decl (TYPE_NAME (scope));
1668 : 68247 : tree not_tmpl = STRIP_TEMPLATE (origin);
1669 : 68247 : if (!DECL_LANG_SPECIFIC (not_tmpl)
1670 : 116744 : || !DECL_MODULE_IMPORT_P (not_tmpl))
1671 : : /* Not imported. */
1672 : 60092 : continue;
1673 : :
1674 : 8155 : unsigned module = get_importing_module (origin);
1675 : :
1676 : 8155 : if (!bitmap_bit_p (inst_path, module))
1677 : : /* Not on path of instantiation. */
1678 : 3 : continue;
1679 : :
1680 : 8152 : if (bitmap_bit_p (visible, module))
1681 : : /* If the module was in the visible set, we'll look at
1682 : : its namespace partition anyway. */
1683 : 8152 : continue;
1684 : :
1685 : 0 : if (tree *slot = find_namespace_slot (ctx, name, false))
1686 : 0 : if (binding_slot *mslot = search_imported_binding_slot (slot, module))
1687 : : {
1688 : 0 : if (mslot->is_lazy ())
1689 : 0 : lazy_load_binding (module, ctx, name, mslot);
1690 : :
1691 : 0 : if (tree bind = *mslot)
1692 : : {
1693 : : /* We must turn on deduping, because some other class
1694 : : from this module might also be in this namespace. */
1695 : 0 : dedup (true);
1696 : :
1697 : : /* Add the exported fns */
1698 : 0 : if (STAT_HACK_P (bind))
1699 : 0 : add_fns (STAT_VISIBLE (bind));
1700 : : }
1701 : : }
1702 : : }
1703 : : }
1704 : :
1705 : 17718327 : fns = value;
1706 : 17718327 : dedup (false);
1707 : : }
1708 : :
1709 : 32133817 : return fns;
1710 : : }
1711 : :
1712 : : static bool qualified_namespace_lookup (tree, name_lookup *);
1713 : : static void consider_binding_level (tree name,
1714 : : best_match <tree, const char *> &bm,
1715 : : cp_binding_level *lvl,
1716 : : bool look_within_fields,
1717 : : enum lookup_name_fuzzy_kind kind);
1718 : :
1719 : : /* ADL lookup of NAME. FNS is the result of regular lookup, and we
1720 : : don't add duplicates to it. ARGS is the vector of call
1721 : : arguments (which will not be empty). */
1722 : :
1723 : : tree
1724 : 32133817 : lookup_arg_dependent (tree name, tree fns, vec<tree, va_gc> *args)
1725 : : {
1726 : 32133817 : auto_cond_timevar tv (TV_NAME_LOOKUP);
1727 : 32133817 : name_lookup lookup (name);
1728 : 32133817 : return lookup.search_adl (fns, args);
1729 : 32133817 : }
1730 : :
1731 : : /* FNS is an overload set of conversion functions. Return the
1732 : : overloads converting to TYPE. */
1733 : :
1734 : : static tree
1735 : 338096 : extract_conversion_operator (tree fns, tree type)
1736 : : {
1737 : 338096 : tree convs = NULL_TREE;
1738 : 338096 : tree tpls = NULL_TREE;
1739 : :
1740 : 1076222 : for (ovl_iterator iter (fns); iter; ++iter)
1741 : : {
1742 : 507084 : if (same_type_p (DECL_CONV_FN_TYPE (*iter), type))
1743 : 405627 : convs = lookup_add (*iter, convs);
1744 : :
1745 : 507084 : if (TREE_CODE (*iter) == TEMPLATE_DECL)
1746 : 62138 : tpls = lookup_add (*iter, tpls);
1747 : : }
1748 : :
1749 : 338096 : if (!convs)
1750 : 67621 : convs = tpls;
1751 : :
1752 : 338096 : return convs;
1753 : : }
1754 : :
1755 : : /* Binary search of (ordered) MEMBER_VEC for NAME. */
1756 : :
1757 : : static tree
1758 : 2625178397 : member_vec_binary_search (vec<tree, va_gc> *member_vec, tree name)
1759 : : {
1760 : 15909187437 : for (unsigned lo = 0, hi = member_vec->length (); lo < hi;)
1761 : : {
1762 : 11310178437 : unsigned mid = (lo + hi) / 2;
1763 : 11310178437 : tree binding = (*member_vec)[mid];
1764 : 22620356874 : tree binding_name = OVL_NAME (binding);
1765 : :
1766 : 11310178437 : if (binding_name > name)
1767 : : hi = mid;
1768 : 5572209426 : else if (binding_name < name)
1769 : 4920861632 : lo = mid + 1;
1770 : : else
1771 : 651347794 : return binding;
1772 : : }
1773 : :
1774 : : return NULL_TREE;
1775 : : }
1776 : :
1777 : : /* Linear search of (unordered) MEMBER_VEC for NAME. */
1778 : :
1779 : : static tree
1780 : 643972839 : member_vec_linear_search (vec<tree, va_gc> *member_vec, tree name)
1781 : : {
1782 : 6141271139 : for (int ix = member_vec->length (); ix--;)
1783 : 5546110265 : if (tree binding = (*member_vec)[ix])
1784 : 5546110265 : if (OVL_NAME (binding) == name)
1785 : 48811965 : return binding;
1786 : :
1787 : : return NULL_TREE;
1788 : : }
1789 : :
1790 : : /* Linear search of (partially ordered) fields of KLASS for NAME. */
1791 : :
1792 : : static tree
1793 : 2307604501 : fields_linear_search (tree klass, tree name, bool want_type)
1794 : : {
1795 : 34164838546 : for (tree fields = TYPE_FIELDS (klass); fields; fields = DECL_CHAIN (fields))
1796 : : {
1797 : 31943315715 : tree decl = fields;
1798 : :
1799 : 31943315715 : if (TREE_CODE (decl) == FIELD_DECL
1800 : 31943315715 : && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
1801 : : {
1802 : 30290541 : if (tree temp = search_anon_aggr (TREE_TYPE (decl), name, want_type))
1803 : 12168 : return temp;
1804 : : }
1805 : :
1806 : 31943303547 : if (DECL_NAME (decl) != name)
1807 : 31815408399 : continue;
1808 : :
1809 : 127895148 : if (TREE_CODE (decl) == USING_DECL)
1810 : : {
1811 : 847462 : decl = strip_using_decl (decl);
1812 : 847462 : if (is_overloaded_fn (decl))
1813 : 209101 : continue;
1814 : : }
1815 : :
1816 : 127686047 : if (DECL_DECLARES_FUNCTION_P (decl))
1817 : : /* Functions are found separately. */
1818 : 41186962 : continue;
1819 : :
1820 : 86499085 : if (!want_type || DECL_DECLARES_TYPE_P (decl))
1821 : 86069502 : return decl;
1822 : : }
1823 : :
1824 : : return NULL_TREE;
1825 : : }
1826 : :
1827 : : /* Like fields_linear_search, but specific for "_" name. There can be multiple
1828 : : name-independent non-static data members and in that case a TREE_LIST with the
1829 : : ambiguous decls should be returned. */
1830 : :
1831 : : static tree
1832 : 615 : name_independent_linear_search (tree val, tree klass, tree name)
1833 : : {
1834 : 3058 : for (tree fields = TYPE_FIELDS (klass); fields; fields = DECL_CHAIN (fields))
1835 : : {
1836 : 2443 : tree decl = fields;
1837 : :
1838 : 2443 : if (TREE_CODE (decl) == FIELD_DECL
1839 : 2443 : && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
1840 : : {
1841 : 0 : if (tree temp = search_anon_aggr (TREE_TYPE (decl), name, false))
1842 : : {
1843 : 0 : decl = temp;
1844 : 0 : goto add;
1845 : : }
1846 : : }
1847 : :
1848 : 2443 : if (DECL_NAME (decl) != name)
1849 : 2431 : continue;
1850 : :
1851 : 12 : if (TREE_CODE (decl) == USING_DECL)
1852 : : {
1853 : 0 : decl = strip_using_decl (decl);
1854 : 0 : if (is_overloaded_fn (decl))
1855 : 0 : continue;
1856 : : }
1857 : :
1858 : 12 : if (DECL_DECLARES_FUNCTION_P (decl))
1859 : : /* Functions are found separately. */
1860 : 0 : continue;
1861 : :
1862 : 12 : add:
1863 : 12 : if (val == NULL_TREE)
1864 : : val = decl;
1865 : : else
1866 : : {
1867 : 3 : if (TREE_CODE (val) != TREE_LIST)
1868 : : {
1869 : 3 : if (TREE_CODE (val) == OVERLOAD
1870 : 0 : && OVL_DEDUP_P (val)
1871 : 3 : && TREE_CODE (decl) == USING_DECL)
1872 : : {
1873 : 0 : val = ovl_make (decl, val);
1874 : 0 : continue;
1875 : : }
1876 : 3 : val = tree_cons (NULL_TREE, val, NULL_TREE);
1877 : 3 : TREE_TYPE (val) = error_mark_node;
1878 : : }
1879 : 3 : if (TREE_CODE (decl) == TREE_LIST)
1880 : 0 : val = chainon (decl, val);
1881 : : else
1882 : : {
1883 : 3 : val = tree_cons (NULL_TREE, decl, val);
1884 : 3 : TREE_TYPE (val) = error_mark_node;
1885 : : }
1886 : : }
1887 : : }
1888 : :
1889 : 615 : return val;
1890 : : }
1891 : :
1892 : : /* Look for NAME member inside of anonymous aggregate ANON. Although
1893 : : such things should only contain FIELD_DECLs, we check that too
1894 : : late, and would give very confusing errors if we weren't
1895 : : permissive here. */
1896 : :
1897 : : tree
1898 : 30290541 : search_anon_aggr (tree anon, tree name, bool want_type)
1899 : : {
1900 : 30290541 : gcc_assert (COMPLETE_TYPE_P (anon));
1901 : 30290541 : tree ret = get_class_binding_direct (anon, name, want_type);
1902 : 30290541 : return ret;
1903 : : }
1904 : :
1905 : : /* Look for NAME as an immediate member of KLASS (including
1906 : : anon-members or unscoped enum member). TYPE_OR_FNS is zero for
1907 : : regular search. >0 to get a type binding (if there is one) and <0
1908 : : if you want (just) the member function binding.
1909 : :
1910 : : Use this if you do not want lazy member creation. */
1911 : :
1912 : : tree
1913 : 4981073562 : get_class_binding_direct (tree klass, tree name, bool want_type)
1914 : : {
1915 : 4981073562 : gcc_checking_assert (RECORD_OR_UNION_TYPE_P (klass));
1916 : :
1917 : : /* Conversion operators can only be found by the marker conversion
1918 : : operator name. */
1919 : 4981073562 : bool conv_op = IDENTIFIER_CONV_OP_P (name);
1920 : 4981073562 : tree lookup = conv_op ? conv_op_identifier : name;
1921 : 4981073562 : tree val = NULL_TREE;
1922 : 4981073562 : vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
1923 : :
1924 : 4981073562 : if (COMPLETE_TYPE_P (klass) && member_vec)
1925 : : {
1926 : 2624855634 : val = member_vec_binary_search (member_vec, lookup);
1927 : 2624855634 : if (!val)
1928 : : ;
1929 : 651025610 : else if (TREE_CODE (val) == OVERLOAD
1930 : 651025610 : && OVL_NAME_INDEPENDENT_DECL_P (val))
1931 : : {
1932 : 160 : if (want_type)
1933 : : {
1934 : 120 : while (TREE_CODE (val) == OVERLOAD
1935 : 120 : && OVL_NAME_INDEPENDENT_DECL_P (val))
1936 : 63 : val = OVL_CHAIN (val);
1937 : 57 : if (STAT_HACK_P (val))
1938 : 12 : val = STAT_TYPE (val);
1939 : 45 : else if (!DECL_DECLARES_TYPE_P (val))
1940 : : val = NULL_TREE;
1941 : : }
1942 : : else
1943 : : {
1944 : : /* OVERLOAD with a special OVL_NAME_INDEPENDENT_DECL_P
1945 : : flag is used under the hood to represent lookup
1946 : : results which include name-independent declarations,
1947 : : and get_class_binding_direct is turning that into
1948 : : TREE_LIST representation (which the callers expect for
1949 : : ambiguous lookups) instead.
1950 : : There are 2 reasons for that:
1951 : : 1) in order to keep the member_vec binary search fast, I
1952 : : think it is better to keep OVL_NAME usable on all elements
1953 : : because having to special case TREE_LIST would slow
1954 : : everything down;
1955 : : 2) the callers need to be able to chain the results anyway
1956 : : and so need an unshared TREE_LIST they can tweak/destroy. */
1957 : : tree ovl = val;
1958 : : val = NULL_TREE;
1959 : 218 : while (TREE_CODE (ovl) == OVERLOAD
1960 : 218 : && OVL_NAME_INDEPENDENT_DECL_P (ovl))
1961 : : {
1962 : 115 : val = tree_cons (NULL_TREE, OVL_FUNCTION (ovl), val);
1963 : 115 : TREE_TYPE (val) = error_mark_node;
1964 : 115 : ovl = OVL_CHAIN (ovl);
1965 : : }
1966 : 103 : if (STAT_HACK_P (ovl))
1967 : 6 : val = tree_cons (NULL_TREE, STAT_DECL (ovl), val);
1968 : : else
1969 : 97 : val = tree_cons (NULL_TREE, ovl, val);
1970 : 103 : TREE_TYPE (val) = error_mark_node;
1971 : : }
1972 : : }
1973 : 651025450 : else if (STAT_HACK_P (val))
1974 : 201 : val = want_type ? STAT_TYPE (val) : STAT_DECL (val);
1975 : 651025249 : else if (want_type && !DECL_DECLARES_TYPE_P (val))
1976 : : val = NULL_TREE;
1977 : : }
1978 : : else
1979 : : {
1980 : 2356217928 : if (member_vec && !want_type)
1981 : 643972839 : val = member_vec_linear_search (member_vec, lookup);
1982 : :
1983 : 2356217928 : if (id_equal (lookup, "_") && !want_type)
1984 : 615 : val = name_independent_linear_search (val, klass, lookup);
1985 : 2356217313 : else if (!val || (TREE_CODE (val) == OVERLOAD && OVL_DEDUP_P (val)))
1986 : : /* Dependent using declarations are a 'field', make sure we
1987 : : return that even if we saw an overload already. */
1988 : 2307601359 : if (tree field_val = fields_linear_search (klass, lookup, want_type))
1989 : : {
1990 : 86078528 : if (!val)
1991 : : val = field_val;
1992 : 0 : else if (TREE_CODE (field_val) == USING_DECL)
1993 : 0 : val = ovl_make (field_val, val);
1994 : : }
1995 : : }
1996 : :
1997 : : /* Extract the conversion operators asked for, unless the general
1998 : : conversion operator was requested. */
1999 : 4981073562 : if (val && conv_op)
2000 : : {
2001 : 14365360 : gcc_checking_assert (OVL_FUNCTION (val) == conv_op_marker);
2002 : 14365360 : val = OVL_CHAIN (val);
2003 : 14365360 : if (tree type = TREE_TYPE (name))
2004 : 338096 : val = extract_conversion_operator (val, type);
2005 : : }
2006 : :
2007 : 4981073562 : return val;
2008 : : }
2009 : :
2010 : : /* We're about to lookup NAME in KLASS. Make sure any lazily declared
2011 : : members are now declared. */
2012 : :
2013 : : static void
2014 : 2805848005 : maybe_lazily_declare (tree klass, tree name)
2015 : : {
2016 : : /* See big comment anout module_state::write_pendings regarding adding a check
2017 : : bit. */
2018 : 2805848005 : if (modules_p ())
2019 : 11919384 : lazy_load_pendings (TYPE_NAME (klass));
2020 : :
2021 : : /* Lazily declare functions, if we're going to search these. */
2022 : 2805848005 : if (IDENTIFIER_CTOR_P (name))
2023 : : {
2024 : 53705464 : if (CLASSTYPE_LAZY_DEFAULT_CTOR (klass))
2025 : 2205350 : lazily_declare_fn (sfk_constructor, klass);
2026 : 53705464 : if (CLASSTYPE_LAZY_COPY_CTOR (klass))
2027 : 3930186 : lazily_declare_fn (sfk_copy_constructor, klass);
2028 : 53705464 : if (CLASSTYPE_LAZY_MOVE_CTOR (klass))
2029 : 3048204 : lazily_declare_fn (sfk_move_constructor, klass);
2030 : : }
2031 : 2752142541 : else if (IDENTIFIER_DTOR_P (name))
2032 : : {
2033 : 55572913 : if (CLASSTYPE_LAZY_DESTRUCTOR (klass))
2034 : 4437488 : lazily_declare_fn (sfk_destructor, klass);
2035 : : }
2036 : 2696569628 : else if (name == assign_op_identifier)
2037 : : {
2038 : 11261816 : if (CLASSTYPE_LAZY_COPY_ASSIGN (klass))
2039 : 1246805 : lazily_declare_fn (sfk_copy_assignment, klass);
2040 : 11261816 : if (CLASSTYPE_LAZY_MOVE_ASSIGN (klass))
2041 : 849888 : lazily_declare_fn (sfk_move_assignment, klass);
2042 : : }
2043 : 2805848005 : }
2044 : :
2045 : : /* Look for NAME's binding in exactly KLASS. See
2046 : : get_class_binding_direct for argument description. Does lazy
2047 : : special function creation as necessary. */
2048 : :
2049 : : tree
2050 : 4591415644 : get_class_binding (tree klass, tree name, bool want_type /*=false*/)
2051 : : {
2052 : 4591415644 : klass = complete_type (klass);
2053 : :
2054 : 4591415644 : if (COMPLETE_TYPE_P (klass))
2055 : 2805848005 : maybe_lazily_declare (klass, name);
2056 : :
2057 : 4591415644 : return get_class_binding_direct (klass, name, want_type);
2058 : : }
2059 : :
2060 : : /* Find the slot containing overloads called 'NAME'. If there is no
2061 : : such slot and the class is complete, create an empty one, at the
2062 : : correct point in the sorted member vector. Otherwise return NULL.
2063 : : Deals with conv_op marker handling. */
2064 : :
2065 : : tree *
2066 : 275205316 : find_member_slot (tree klass, tree name)
2067 : : {
2068 : 275205316 : bool complete_p = COMPLETE_TYPE_P (klass);
2069 : :
2070 : 275205316 : vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
2071 : 275205316 : if (!member_vec)
2072 : : {
2073 : 19469056 : vec_alloc (member_vec, 8);
2074 : 19469056 : CLASSTYPE_MEMBER_VEC (klass) = member_vec;
2075 : 19469056 : if (complete_p)
2076 : : /* If the class is complete but had no member_vec, we need to
2077 : : add the TYPE_FIELDS into it. We're also most likely to be
2078 : : adding ctors & dtors, so ask for 6 spare slots (the
2079 : : abstract cdtors and their clones). */
2080 : 1801129 : member_vec = set_class_bindings (klass, 6);
2081 : : }
2082 : :
2083 : 275205316 : if (IDENTIFIER_CONV_OP_P (name))
2084 : 1707716 : name = conv_op_identifier;
2085 : :
2086 : 275205316 : unsigned ix, length = member_vec->length ();
2087 : 3354094264 : for (ix = 0; ix < length; ix++)
2088 : : {
2089 : 3214513344 : tree *slot = &(*member_vec)[ix];
2090 : 6429026688 : tree fn_name = OVL_NAME (*slot);
2091 : :
2092 : 3214513344 : if (fn_name == name)
2093 : : {
2094 : : /* If we found an existing slot, it must be a function set.
2095 : : Even with insertion after completion, because those only
2096 : : happen with artificial fns that have unspellable names.
2097 : : This means we do not have to deal with the stat hack
2098 : : either. */
2099 : 129421108 : gcc_checking_assert (OVL_P (*slot));
2100 : 129421108 : if (name == conv_op_identifier)
2101 : : {
2102 : 425787 : gcc_checking_assert (OVL_FUNCTION (*slot) == conv_op_marker);
2103 : : /* Skip the conv-op marker. */
2104 : 425787 : slot = &OVL_CHAIN (*slot);
2105 : : }
2106 : 129421108 : return slot;
2107 : : }
2108 : :
2109 : 3085092236 : if (complete_p && fn_name > name)
2110 : : break;
2111 : : }
2112 : :
2113 : : /* No slot found, add one if the class is complete. */
2114 : 145784208 : if (complete_p)
2115 : : {
2116 : : /* Do exact allocation, as we don't expect to add many. */
2117 : 21140832 : gcc_assert (name != conv_op_identifier);
2118 : 21140832 : vec_safe_reserve_exact (member_vec, 1);
2119 : 21140832 : CLASSTYPE_MEMBER_VEC (klass) = member_vec;
2120 : 21140832 : member_vec->quick_insert (ix, NULL_TREE);
2121 : 21140832 : return &(*member_vec)[ix];
2122 : : }
2123 : :
2124 : : return NULL;
2125 : : }
2126 : :
2127 : : /* KLASS is an incomplete class to which we're adding a method NAME.
2128 : : Add a slot and deal with conv_op marker handling. */
2129 : :
2130 : : tree *
2131 : 124643361 : add_member_slot (tree klass, tree name)
2132 : : {
2133 : 124643361 : gcc_assert (!COMPLETE_TYPE_P (klass));
2134 : :
2135 : 124643361 : vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
2136 : 124643361 : vec_safe_push (member_vec, NULL_TREE);
2137 : 124643361 : CLASSTYPE_MEMBER_VEC (klass) = member_vec;
2138 : :
2139 : 124643361 : tree *slot = &member_vec->last ();
2140 : 124643361 : if (IDENTIFIER_CONV_OP_P (name))
2141 : : {
2142 : : /* Install the marker prefix. */
2143 : 1281929 : *slot = ovl_make (conv_op_marker, NULL_TREE);
2144 : 1281929 : slot = &OVL_CHAIN (*slot);
2145 : : }
2146 : :
2147 : 124643361 : return slot;
2148 : : }
2149 : :
2150 : : /* Comparison function to compare two MEMBER_VEC entries by name.
2151 : : Because we can have duplicates during insertion of TYPE_FIELDS, we
2152 : : do extra checking so deduping doesn't have to deal with so many
2153 : : cases. */
2154 : :
2155 : : static int
2156 : 5040010478 : member_name_cmp (const void *a_p, const void *b_p)
2157 : : {
2158 : 5040010478 : tree a = *(const tree *)a_p;
2159 : 5040010478 : tree b = *(const tree *)b_p;
2160 : 5040010478 : tree name_a = DECL_NAME (TREE_CODE (a) == OVERLOAD ? OVL_FUNCTION (a) : a);
2161 : 5040010478 : tree name_b = DECL_NAME (TREE_CODE (b) == OVERLOAD ? OVL_FUNCTION (b) : b);
2162 : :
2163 : 5040010478 : gcc_checking_assert (name_a && name_b);
2164 : 5040010478 : if (name_a != name_b)
2165 : 7403792871 : return name_a < name_b ? -1 : +1;
2166 : :
2167 : 15444158 : if (name_a == conv_op_identifier)
2168 : : {
2169 : : /* Strip the conv-op markers. */
2170 : 1081858 : gcc_checking_assert (OVL_FUNCTION (a) == conv_op_marker
2171 : : && OVL_FUNCTION (b) == conv_op_marker);
2172 : 540929 : a = OVL_CHAIN (a);
2173 : 540929 : b = OVL_CHAIN (b);
2174 : : }
2175 : :
2176 : 15444158 : if (TREE_CODE (a) == OVERLOAD)
2177 : 5594746 : a = OVL_FUNCTION (a);
2178 : 15444158 : if (TREE_CODE (b) == OVERLOAD)
2179 : 5138192 : b = OVL_FUNCTION (b);
2180 : :
2181 : 15444158 : if (id_equal (name_a, "_"))
2182 : : {
2183 : : /* Sort name-independent members first. */
2184 : 264 : if (name_independent_decl_p (a))
2185 : : {
2186 : 234 : if (name_independent_decl_p (b))
2187 : : {
2188 : 183 : if (DECL_UID (a) != DECL_UID (b))
2189 : 183 : return DECL_UID (a) < DECL_UID (b) ? -1 : +1;
2190 : 0 : gcc_assert (a == b);
2191 : : return 0;
2192 : : }
2193 : : else
2194 : : return -1;
2195 : : }
2196 : 30 : else if (name_independent_decl_p (b))
2197 : : return +1;
2198 : : }
2199 : :
2200 : : /* We're in STAT_HACK or USING_DECL territory (or possibly error-land). */
2201 : 15443894 : if (TREE_CODE (a) != TREE_CODE (b))
2202 : : {
2203 : : /* If one of them is a TYPE_DECL, it loses. */
2204 : 14695019 : if (TREE_CODE (a) == TYPE_DECL)
2205 : : return +1;
2206 : 14694686 : else if (TREE_CODE (b) == TYPE_DECL)
2207 : : return -1;
2208 : :
2209 : : /* If one of them is a USING_DECL, it loses. */
2210 : 14694343 : if (TREE_CODE (a) == USING_DECL)
2211 : : return +1;
2212 : 7628571 : else if (TREE_CODE (b) == USING_DECL)
2213 : : return -1;
2214 : :
2215 : : /* There are no other cases with different kinds of decls, as
2216 : : duplicate detection should have kicked in earlier. However,
2217 : : some erroneous cases get though. */
2218 : 0 : gcc_assert (errorcount);
2219 : : }
2220 : :
2221 : : /* Using source location would be the best thing here, but we can
2222 : : get identically-located decls in the following circumstances:
2223 : :
2224 : : 1) duplicate artificial type-decls for the same type.
2225 : :
2226 : : 2) pack expansions of using-decls.
2227 : :
2228 : : We should not be doing #1, but in either case it doesn't matter
2229 : : how we order these. Use UID as a proxy for source ordering, so
2230 : : that identically-located decls still have a well-defined stable
2231 : : ordering. */
2232 : 748875 : if (DECL_UID (a) != DECL_UID (b))
2233 : 748857 : return DECL_UID (a) < DECL_UID (b) ? -1 : +1;
2234 : 18 : gcc_assert (a == b);
2235 : : return 0;
2236 : : }
2237 : :
2238 : : static struct {
2239 : : gt_pointer_operator new_value;
2240 : : void *cookie;
2241 : : } resort_data;
2242 : :
2243 : : /* This routine compares two fields like member_name_cmp but using the
2244 : : pointer operator in resort_field_decl_data. We don't have to deal
2245 : : with duplicates here. */
2246 : :
2247 : : static int
2248 : 9722984 : resort_member_name_cmp (const void *a_p, const void *b_p)
2249 : : {
2250 : 9722984 : tree a = *(const tree *)a_p;
2251 : 9722984 : tree b = *(const tree *)b_p;
2252 : 19445968 : tree name_a = OVL_NAME (a);
2253 : 19445968 : tree name_b = OVL_NAME (b);
2254 : :
2255 : 9722984 : resort_data.new_value (&name_a, &name_a, resort_data.cookie);
2256 : 9722984 : resort_data.new_value (&name_b, &name_b, resort_data.cookie);
2257 : :
2258 : 9722984 : gcc_checking_assert (name_a != name_b);
2259 : :
2260 : 9722984 : return name_a < name_b ? -1 : +1;
2261 : : }
2262 : :
2263 : : /* Resort CLASSTYPE_MEMBER_VEC because pointers have been reordered. */
2264 : :
2265 : : void
2266 : 59818 : resort_type_member_vec (void *obj, void */*orig_obj*/,
2267 : : gt_pointer_operator new_value, void* cookie)
2268 : : {
2269 : 59818 : if (vec<tree, va_gc> *member_vec = (vec<tree, va_gc> *) obj)
2270 : : {
2271 : 59818 : resort_data.new_value = new_value;
2272 : 59818 : resort_data.cookie = cookie;
2273 : 59818 : member_vec->qsort (resort_member_name_cmp);
2274 : : }
2275 : 59818 : }
2276 : :
2277 : : /* Recursively count the number of fields in KLASS, including anonymous
2278 : : union members. */
2279 : :
2280 : : static unsigned
2281 : 54206000 : count_class_fields (tree klass)
2282 : : {
2283 : 54206000 : unsigned n_fields = 0;
2284 : :
2285 : 477205169 : for (tree fields = TYPE_FIELDS (klass); fields; fields = DECL_CHAIN (fields))
2286 : 422999169 : if (DECL_DECLARES_FUNCTION_P (fields))
2287 : : /* Functions are dealt with separately. */;
2288 : 194061614 : else if (TREE_CODE (fields) == FIELD_DECL
2289 : 194061614 : && ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
2290 : 168014 : n_fields += count_class_fields (TREE_TYPE (fields));
2291 : 193893600 : else if (DECL_NAME (fields))
2292 : 174073644 : n_fields += 1;
2293 : :
2294 : 54206000 : return n_fields;
2295 : : }
2296 : :
2297 : : /* Append all the nonfunction members fields of KLASS to MEMBER_VEC.
2298 : : Recurse for anonymous members. MEMBER_VEC must have space. */
2299 : :
2300 : : static void
2301 : 20076467 : member_vec_append_class_fields (vec<tree, va_gc> *member_vec, tree klass)
2302 : : {
2303 : 361833499 : for (tree fields = TYPE_FIELDS (klass); fields; fields = DECL_CHAIN (fields))
2304 : 341757032 : if (DECL_DECLARES_FUNCTION_P (fields))
2305 : : /* Functions are handled separately. */;
2306 : 112819489 : else if (TREE_CODE (fields) == FIELD_DECL
2307 : 112819489 : && ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
2308 : 157658 : member_vec_append_class_fields (member_vec, TREE_TYPE (fields));
2309 : 112661831 : else if (DECL_NAME (fields))
2310 : : {
2311 : 108060182 : tree field = fields;
2312 : : /* Mark a conv-op USING_DECL with the conv-op-marker. */
2313 : 108060182 : if (TREE_CODE (field) == USING_DECL
2314 : 108060182 : && IDENTIFIER_CONV_OP_P (DECL_NAME (field)))
2315 : 135209 : field = ovl_make (conv_op_marker, field);
2316 : 108060182 : member_vec->quick_push (field);
2317 : : }
2318 : 20076467 : }
2319 : :
2320 : : /* Append all of the enum values of ENUMTYPE to MEMBER_VEC.
2321 : : MEMBER_VEC must have space. */
2322 : :
2323 : : static void
2324 : 21 : member_vec_append_enum_values (vec<tree, va_gc> *member_vec, tree enumtype)
2325 : : {
2326 : 21 : for (tree values = TYPE_VALUES (enumtype);
2327 : 51 : values; values = TREE_CHAIN (values))
2328 : 30 : member_vec->quick_push (TREE_VALUE (values));
2329 : 21 : }
2330 : :
2331 : : /* MEMBER_VEC has just had new DECLs added to it, but is sorted.
2332 : : DeDup adjacent DECLS of the same name. We already dealt with
2333 : : conflict resolution when adding the fields or methods themselves.
2334 : : There are four cases (which could all be combined):
2335 : : 1) a TYPE_DECL and non TYPE_DECL. Deploy STAT_HACK as appropriate.
2336 : : 2) a USING_DECL and an overload. If the USING_DECL is dependent,
2337 : : it wins. Otherwise the OVERLOAD does.
2338 : : 3) two USING_DECLS.
2339 : : 4) name-independent members plus others. ...
2340 : :
2341 : : member_name_cmp will have ordered duplicates as
2342 : : <name_independent><fns><using><type> */
2343 : :
2344 : : static void
2345 : 19918830 : member_vec_dedup (vec<tree, va_gc> *member_vec)
2346 : : {
2347 : 19918830 : unsigned len = member_vec->length ();
2348 : 19918830 : unsigned store = 0;
2349 : :
2350 : 19918830 : if (!len)
2351 : : return;
2352 : :
2353 : 39837656 : tree name = OVL_NAME ((*member_vec)[0]);
2354 : 248803278 : for (unsigned jx, ix = 0; ix < len; ix = jx)
2355 : : {
2356 : : tree current = NULL_TREE;
2357 : : tree to_type = NULL_TREE;
2358 : : tree to_using = NULL_TREE;
2359 : : tree marker = NULL_TREE;
2360 : : unsigned name_independent = ix;
2361 : :
2362 : 461588137 : for (jx = ix; jx < len; jx++)
2363 : : {
2364 : 441669309 : tree next = (*member_vec)[jx];
2365 : 441669309 : if (jx != ix)
2366 : : {
2367 : 212784859 : tree next_name = OVL_NAME (next);
2368 : 212784859 : if (next_name != name)
2369 : : {
2370 : : name = next_name;
2371 : : break;
2372 : : }
2373 : : }
2374 : :
2375 : 232703687 : if (IDENTIFIER_CONV_OP_P (name))
2376 : : {
2377 : 1417138 : marker = next;
2378 : 1417138 : next = OVL_CHAIN (next);
2379 : : }
2380 : :
2381 : 232703687 : if (TREE_CODE (next) == USING_DECL)
2382 : : {
2383 : 9647495 : if (IDENTIFIER_CTOR_P (name))
2384 : : /* Dependent inherited ctor. */
2385 : 197422 : continue;
2386 : :
2387 : 9450073 : next = strip_using_decl (next);
2388 : 9450073 : if (TREE_CODE (next) == USING_DECL)
2389 : : {
2390 : 7673588 : to_using = next;
2391 : 7673588 : continue;
2392 : : }
2393 : :
2394 : 1776485 : if (is_overloaded_fn (next))
2395 : 1388469 : continue;
2396 : : }
2397 : :
2398 : 223444208 : if (DECL_DECLARES_TYPE_P (next))
2399 : : {
2400 : 66008914 : to_type = next;
2401 : 66008914 : continue;
2402 : : }
2403 : :
2404 : 157435294 : if (name_independent_decl_p (next))
2405 : 138 : name_independent = jx + 1;
2406 : 157435156 : else if (!current)
2407 : 157133774 : current = next;
2408 : : }
2409 : :
2410 : 228884450 : if (to_using)
2411 : : {
2412 : 7646133 : if (!current)
2413 : : current = to_using;
2414 : : else
2415 : 1766783 : current = ovl_make (to_using, current);
2416 : : }
2417 : :
2418 : 228884450 : if (to_type)
2419 : : {
2420 : 65851133 : if (!current)
2421 : : current = to_type;
2422 : : else
2423 : 159 : current = stat_hack (current, to_type);
2424 : : }
2425 : :
2426 : 228884588 : for (unsigned kx = name_independent; kx > ix; --kx)
2427 : 138 : if (!current)
2428 : 84 : current = (*member_vec)[kx - 1];
2429 : 54 : else if (current == to_type)
2430 : 6 : current = stat_hack ((*member_vec)[kx - 1], to_type);
2431 : : else
2432 : : {
2433 : 48 : current = ovl_make ((*member_vec)[kx - 1], current);
2434 : 48 : OVL_NAME_INDEPENDENT_DECL_P (current) = 1;
2435 : : }
2436 : :
2437 : 228884450 : if (current)
2438 : : {
2439 : 228864182 : if (marker)
2440 : : {
2441 : 1281929 : OVL_CHAIN (marker) = current;
2442 : 1281929 : current = marker;
2443 : : }
2444 : 228864182 : (*member_vec)[store++] = current;
2445 : : }
2446 : : }
2447 : :
2448 : 23758333 : while (store++ < len)
2449 : 3839505 : member_vec->pop ();
2450 : : }
2451 : :
2452 : : /* Add the non-function members to CLASSTYPE_MEMBER_VEC. If there is
2453 : : no existing MEMBER_VEC and fewer than 8 fields, do nothing. We
2454 : : know there must be at least 1 field -- the self-reference
2455 : : TYPE_DECL, except for anon aggregates, which will have at least
2456 : : one field anyway. If EXTRA < 0, always create the vector. */
2457 : :
2458 : : vec<tree, va_gc> *
2459 : 54037965 : set_class_bindings (tree klass, int extra)
2460 : : {
2461 : 54037965 : unsigned n_fields = count_class_fields (klass);
2462 : 54037965 : vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
2463 : :
2464 : 54037965 : if (member_vec || n_fields >= 8 || extra < 0)
2465 : : {
2466 : : /* Append the new fields. */
2467 : 19918803 : vec_safe_reserve_exact (member_vec, n_fields + (extra >= 0 ? extra : 0));
2468 : 19918803 : member_vec_append_class_fields (member_vec, klass);
2469 : : }
2470 : :
2471 : 54037965 : if (member_vec)
2472 : : {
2473 : 19918803 : CLASSTYPE_MEMBER_VEC (klass) = member_vec;
2474 : 19918803 : member_vec->qsort (member_name_cmp);
2475 : 19918803 : member_vec_dedup (member_vec);
2476 : : }
2477 : :
2478 : 54037965 : return member_vec;
2479 : : }
2480 : :
2481 : : /* Insert lately defined enum ENUMTYPE into KLASS for the sorted case. */
2482 : :
2483 : : void
2484 : 42 : insert_late_enum_def_bindings (tree klass, tree enumtype)
2485 : : {
2486 : 42 : int n_fields;
2487 : 42 : vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
2488 : :
2489 : : /* The enum bindings will already be on the TYPE_FIELDS, so don't
2490 : : count them twice. */
2491 : 42 : if (!member_vec)
2492 : 21 : n_fields = count_class_fields (klass);
2493 : : else
2494 : 21 : n_fields = list_length (TYPE_VALUES (enumtype));
2495 : :
2496 : 42 : if (member_vec || n_fields >= 8)
2497 : : {
2498 : 27 : vec_safe_reserve_exact (member_vec, n_fields);
2499 : 27 : if (CLASSTYPE_MEMBER_VEC (klass))
2500 : 21 : member_vec_append_enum_values (member_vec, enumtype);
2501 : : else
2502 : 6 : member_vec_append_class_fields (member_vec, klass);
2503 : 27 : CLASSTYPE_MEMBER_VEC (klass) = member_vec;
2504 : 27 : member_vec->qsort (member_name_cmp);
2505 : 27 : member_vec_dedup (member_vec);
2506 : : }
2507 : 42 : }
2508 : :
2509 : : /* The binding oracle; see cp-tree.h. */
2510 : :
2511 : : cp_binding_oracle_function *cp_binding_oracle;
2512 : :
2513 : : /* If we have a binding oracle, ask it for all namespace-scoped
2514 : : definitions of NAME. */
2515 : :
2516 : : static inline void
2517 : 4242219336 : query_oracle (tree name)
2518 : : {
2519 : 4242219336 : if (!cp_binding_oracle)
2520 : : return;
2521 : :
2522 : : /* LOOKED_UP holds the set of identifiers that we have already
2523 : : looked up with the oracle. */
2524 : 0 : static hash_set<tree> looked_up;
2525 : 0 : if (looked_up.add (name))
2526 : : return;
2527 : :
2528 : 0 : cp_binding_oracle (CP_ORACLE_IDENTIFIER, name);
2529 : : }
2530 : :
2531 : : #ifndef ENABLE_SCOPE_CHECKING
2532 : : # define ENABLE_SCOPE_CHECKING 0
2533 : : #else
2534 : : # define ENABLE_SCOPE_CHECKING 1
2535 : : #endif
2536 : :
2537 : : /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
2538 : :
2539 : : static GTY((deletable)) cxx_binding *free_bindings;
2540 : :
2541 : : /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
2542 : : field to NULL. */
2543 : :
2544 : : static inline void
2545 : 1164473131 : cxx_binding_init (cxx_binding *binding, tree value, tree type)
2546 : : {
2547 : 1164473131 : binding->value = value;
2548 : 1164473131 : binding->type = type;
2549 : 1164473131 : binding->previous = NULL;
2550 : : }
2551 : :
2552 : : /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
2553 : :
2554 : : static cxx_binding *
2555 : 1164473131 : cxx_binding_make (tree value, tree type)
2556 : : {
2557 : 1164473131 : cxx_binding *binding = free_bindings;
2558 : :
2559 : 1164473131 : if (binding)
2560 : 1155791895 : free_bindings = binding->previous;
2561 : : else
2562 : 8681236 : binding = ggc_alloc<cxx_binding> ();
2563 : :
2564 : : /* Clear flags by default. */
2565 : 1164473131 : LOCAL_BINDING_P (binding) = false;
2566 : 1164473131 : INHERITED_VALUE_BINDING_P (binding) = false;
2567 : 1164473131 : HIDDEN_TYPE_BINDING_P (binding) = false;
2568 : :
2569 : 1164473131 : cxx_binding_init (binding, value, type);
2570 : :
2571 : 1164473131 : return binding;
2572 : : }
2573 : :
2574 : : /* Put BINDING back on the free list. */
2575 : :
2576 : : static inline void
2577 : 1164470269 : cxx_binding_free (cxx_binding *binding)
2578 : : {
2579 : 1164470269 : binding->scope = NULL;
2580 : 1164470269 : binding->previous = free_bindings;
2581 : 1164470269 : free_bindings = binding;
2582 : 771477862 : }
2583 : :
2584 : : /* Create a new binding for NAME (with the indicated VALUE and TYPE
2585 : : bindings) in the class scope indicated by SCOPE. */
2586 : :
2587 : : static cxx_binding *
2588 : 392995245 : new_class_binding (tree name, tree value, tree type, cp_binding_level *scope)
2589 : : {
2590 : 392995245 : cp_class_binding cb = {cxx_binding_make (value, type), name};
2591 : 392995245 : cxx_binding *binding = cb.base;
2592 : 392995245 : vec_safe_push (scope->class_shadowed, cb);
2593 : 392995245 : binding->scope = scope;
2594 : 392995245 : return binding;
2595 : : }
2596 : :
2597 : : /* Make DECL the innermost binding for ID. The LEVEL is the binding
2598 : : level at which this declaration is being bound. */
2599 : :
2600 : : void
2601 : 260808498 : push_binding (tree id, tree decl, cp_binding_level* level)
2602 : : {
2603 : 260808498 : cxx_binding *binding;
2604 : :
2605 : 260808498 : if (level != class_binding_level)
2606 : : {
2607 : 670022 : binding = cxx_binding_make (decl, NULL_TREE);
2608 : 670022 : binding->scope = level;
2609 : : }
2610 : : else
2611 : 260138476 : binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
2612 : :
2613 : : /* Now, fill in the binding information. */
2614 : 260808498 : binding->previous = IDENTIFIER_BINDING (id);
2615 : 260808498 : LOCAL_BINDING_P (binding) = (level != class_binding_level);
2616 : :
2617 : : /* And put it on the front of the list of bindings for ID. */
2618 : 260808498 : IDENTIFIER_BINDING (id) = binding;
2619 : 260808498 : }
2620 : :
2621 : : /* Remove the binding for DECL which should be the innermost binding
2622 : : for ID. */
2623 : :
2624 : : void
2625 : 795288789 : pop_local_binding (tree id, tree decl)
2626 : : {
2627 : 1567504443 : if (!id || IDENTIFIER_ANON_P (id))
2628 : : /* It's easiest to write the loops that call this function without
2629 : : checking whether or not the entities involved have names. We
2630 : : get here for such an entity. */
2631 : : return;
2632 : :
2633 : : /* Get the innermost binding for ID. */
2634 : 771478132 : cxx_binding *binding = IDENTIFIER_BINDING (id);
2635 : :
2636 : : /* The name should be bound. */
2637 : 771478132 : gcc_assert (binding != NULL);
2638 : :
2639 : : /* The DECL will be either the ordinary binding or the type binding
2640 : : for this identifier. Remove that binding. We don't have to
2641 : : clear HIDDEN_TYPE_BINDING_P, as the whole binding will be going
2642 : : away. */
2643 : 771478132 : if (binding->value == decl)
2644 : 771477697 : binding->value = NULL_TREE;
2645 : 435 : else if (binding->type == decl)
2646 : 144 : binding->type = NULL_TREE;
2647 : : else
2648 : : {
2649 : : /* Name-independent variable was found after at least one declaration
2650 : : with the same name. */
2651 : 291 : gcc_assert (TREE_CODE (binding->value) == TREE_LIST);
2652 : 291 : if (TREE_VALUE (binding->value) != decl)
2653 : : {
2654 : 108 : binding->value = nreverse (binding->value);
2655 : : /* Skip over TREE_LISTs added in pushdecl for check_local_shadow
2656 : : detected declarations, formerly at the tail, now at the start
2657 : : of the list. */
2658 : 108 : while (TREE_PURPOSE (binding->value) == error_mark_node)
2659 : 0 : binding->value = TREE_CHAIN (binding->value);
2660 : : }
2661 : 291 : gcc_assert (TREE_VALUE (binding->value) == decl);
2662 : 291 : binding->value = TREE_CHAIN (binding->value);
2663 : 291 : while (binding->value
2664 : 348 : && TREE_PURPOSE (binding->value) == error_mark_node)
2665 : 57 : binding->value = TREE_CHAIN (binding->value);
2666 : : }
2667 : :
2668 : 771478132 : if (!binding->value && !binding->type)
2669 : : {
2670 : : /* We're completely done with the innermost binding for this
2671 : : identifier. Unhook it from the list of bindings. */
2672 : 771477862 : IDENTIFIER_BINDING (id) = binding->previous;
2673 : :
2674 : : /* Add it to the free list. */
2675 : 771477862 : cxx_binding_free (binding);
2676 : : }
2677 : : }
2678 : :
2679 : : /* Remove the bindings for the decls of the current level and leave
2680 : : the current scope. */
2681 : :
2682 : : void
2683 : 180526107 : pop_bindings_and_leave_scope (void)
2684 : : {
2685 : 415008414 : for (tree t = get_local_decls (); t; t = DECL_CHAIN (t))
2686 : : {
2687 : 234482307 : tree decl = TREE_CODE (t) == TREE_LIST ? TREE_VALUE (t) : t;
2688 : 468964614 : tree name = OVL_NAME (decl);
2689 : :
2690 : 234482307 : pop_local_binding (name, decl);
2691 : : }
2692 : :
2693 : 180526107 : leave_scope ();
2694 : 180526107 : }
2695 : :
2696 : : /* Strip non dependent using declarations. If DECL is dependent,
2697 : : surreptitiously create a typename_type and return it. */
2698 : :
2699 : : tree
2700 : 7281552405 : strip_using_decl (tree decl)
2701 : : {
2702 : 7281552405 : if (decl == NULL_TREE)
2703 : : return NULL_TREE;
2704 : :
2705 : 5080348706 : while (TREE_CODE (decl) == USING_DECL && !DECL_DEPENDENT_P (decl))
2706 : 24083356 : decl = USING_DECL_DECLS (decl);
2707 : :
2708 : 22926941 : if (TREE_CODE (decl) == USING_DECL && DECL_DEPENDENT_P (decl)
2709 : 5079192291 : && USING_DECL_TYPENAME_P (decl))
2710 : : {
2711 : : /* We have found a type introduced by a using
2712 : : declaration at class scope that refers to a dependent
2713 : : type.
2714 : :
2715 : : using typename :: [opt] nested-name-specifier unqualified-id ;
2716 : : */
2717 : 141625 : decl = make_typename_type (USING_DECL_SCOPE (decl),
2718 : 141625 : DECL_NAME (decl),
2719 : : typename_type, tf_error);
2720 : 141625 : if (decl != error_mark_node)
2721 : 141625 : decl = TYPE_NAME (decl);
2722 : : }
2723 : :
2724 : : return decl;
2725 : : }
2726 : :
2727 : : /* Return true if OVL is an overload for an anticipated builtin. */
2728 : :
2729 : : static bool
2730 : 23283720 : anticipated_builtin_p (tree ovl)
2731 : : {
2732 : 23283720 : return (TREE_CODE (ovl) == OVERLOAD
2733 : 21187807 : && OVL_HIDDEN_P (ovl)
2734 : 29270157 : && DECL_IS_UNDECLARED_BUILTIN (OVL_FUNCTION (ovl)));
2735 : : }
2736 : :
2737 : : /* BINDING records an existing declaration for a name in the current scope.
2738 : : But, DECL is another declaration for that same identifier in the
2739 : : same scope. This is the `struct stat' hack whereby a non-typedef
2740 : : class name or enum-name can be bound at the same level as some other
2741 : : kind of entity.
2742 : : 3.3.7/1
2743 : :
2744 : : A class name (9.1) or enumeration name (7.2) can be hidden by the
2745 : : name of an object, function, or enumerator declared in the same scope.
2746 : : If a class or enumeration name and an object, function, or enumerator
2747 : : are declared in the same scope (in any order) with the same name, the
2748 : : class or enumeration name is hidden wherever the object, function, or
2749 : : enumerator name is visible.
2750 : :
2751 : : It's the responsibility of the caller to check that
2752 : : inserting this name is valid here. Returns nonzero if the new binding
2753 : : was successful. */
2754 : :
2755 : : static bool
2756 : 317937 : supplement_binding (cxx_binding *binding, tree decl)
2757 : : {
2758 : 317937 : auto_cond_timevar tv (TV_NAME_LOOKUP);
2759 : :
2760 : 317937 : tree bval = binding->value;
2761 : 317937 : bool ok = true;
2762 : 317937 : if (bval
2763 : 317937 : && TREE_CODE (bval) == TREE_LIST
2764 : 317943 : && name_independent_decl_p (TREE_VALUE (bval)))
2765 : : bval = TREE_VALUE (bval);
2766 : 317937 : tree target_bval = strip_using_decl (bval);
2767 : 317937 : tree target_decl = strip_using_decl (decl);
2768 : :
2769 : 16207 : if (TREE_CODE (target_decl) == TYPE_DECL && DECL_ARTIFICIAL (target_decl)
2770 : 16033 : && target_decl != target_bval
2771 : 333961 : && (TREE_CODE (target_bval) != TYPE_DECL
2772 : : /* We allow pushing an enum multiple times in a class
2773 : : template in order to handle late matching of underlying
2774 : : type on an opaque-enum-declaration followed by an
2775 : : enum-specifier. */
2776 : 15922 : || (processing_template_decl
2777 : 2166 : && TREE_CODE (TREE_TYPE (target_decl)) == ENUMERAL_TYPE
2778 : 0 : && TREE_CODE (TREE_TYPE (target_bval)) == ENUMERAL_TYPE
2779 : 0 : && (dependent_type_p (ENUM_UNDERLYING_TYPE
2780 : : (TREE_TYPE (target_decl)))
2781 : 0 : || dependent_type_p (ENUM_UNDERLYING_TYPE
2782 : : (TREE_TYPE (target_bval)))))))
2783 : : /* The new name is the type name. */
2784 : 102 : binding->type = decl;
2785 : 317835 : else if (/* TARGET_BVAL is null when push_class_level_binding moves
2786 : : an inherited type-binding out of the way to make room
2787 : : for a new value binding. */
2788 : : !target_bval
2789 : : /* TARGET_BVAL is error_mark_node when TARGET_DECL's name
2790 : : has been used in a non-class scope prior declaration.
2791 : : In that case, we should have already issued a
2792 : : diagnostic; for graceful error recovery purpose, pretend
2793 : : this was the intended declaration for that name. */
2794 : 317835 : || target_bval == error_mark_node
2795 : : /* If TARGET_BVAL is anticipated but has not yet been
2796 : : declared, pretend it is not there at all. */
2797 : 635670 : || anticipated_builtin_p (target_bval))
2798 : 0 : binding->value = decl;
2799 : 317835 : else if (TREE_CODE (target_bval) == TYPE_DECL
2800 : 16285 : && DECL_ARTIFICIAL (target_bval)
2801 : 16252 : && target_decl != target_bval
2802 : 334078 : && (TREE_CODE (target_decl) != TYPE_DECL
2803 : 16063 : || same_type_p (TREE_TYPE (target_decl),
2804 : : TREE_TYPE (target_bval))))
2805 : : {
2806 : : /* The old binding was a type name. It was placed in
2807 : : VALUE field because it was thought, at the point it was
2808 : : declared, to be the only entity with such a name. Move the
2809 : : type name into the type slot; it is now hidden by the new
2810 : : binding. */
2811 : 16231 : binding->type = bval;
2812 : 16231 : binding->value = decl;
2813 : 16231 : binding->value_is_inherited = false;
2814 : : }
2815 : 301604 : else if (TREE_CODE (target_bval) == TYPE_DECL
2816 : 54 : && TREE_CODE (target_decl) == TYPE_DECL
2817 : 54 : && DECL_NAME (target_decl) == DECL_NAME (target_bval)
2818 : 54 : && binding->scope->kind != sk_class
2819 : 301604 : && (same_type_p (TREE_TYPE (target_decl), TREE_TYPE (target_bval))
2820 : : /* If either type involves template parameters, we must
2821 : : wait until instantiation. */
2822 : 0 : || uses_template_parms (TREE_TYPE (target_decl))
2823 : 0 : || uses_template_parms (TREE_TYPE (target_bval))))
2824 : : /* We have two typedef-names, both naming the same type to have
2825 : : the same name. In general, this is OK because of:
2826 : :
2827 : : [dcl.typedef]
2828 : :
2829 : : In a given scope, a typedef specifier can be used to redefine
2830 : : the name of any type declared in that scope to refer to the
2831 : : type to which it already refers.
2832 : :
2833 : : However, in class scopes, this rule does not apply due to the
2834 : : stricter language in [class.mem] prohibiting redeclarations of
2835 : : members. */
2836 : : ok = false;
2837 : : /* There can be two block-scope declarations of the same variable,
2838 : : so long as they are `extern' declarations. However, there cannot
2839 : : be two declarations of the same static data member:
2840 : :
2841 : : [class.mem]
2842 : :
2843 : : A member shall not be declared twice in the
2844 : : member-specification. */
2845 : 301604 : else if (VAR_P (target_decl)
2846 : 6 : && VAR_P (target_bval)
2847 : 6 : && DECL_EXTERNAL (target_decl) && DECL_EXTERNAL (target_bval)
2848 : 301610 : && !DECL_CLASS_SCOPE_P (target_decl))
2849 : : {
2850 : 0 : duplicate_decls (decl, binding->value);
2851 : 0 : ok = false;
2852 : : }
2853 : 301604 : else if (TREE_CODE (decl) == NAMESPACE_DECL
2854 : 0 : && TREE_CODE (bval) == NAMESPACE_DECL
2855 : 0 : && DECL_NAMESPACE_ALIAS (decl)
2856 : 0 : && DECL_NAMESPACE_ALIAS (bval)
2857 : 301604 : && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
2858 : : /* [namespace.alias]
2859 : :
2860 : : In a declarative region, a namespace-alias-definition can be
2861 : : used to redefine a namespace-alias declared in that declarative
2862 : : region to refer only to the namespace to which it already
2863 : : refers. */
2864 : : ok = false;
2865 : 301604 : else if (TREE_CODE (bval) == USING_DECL
2866 : 301604 : && CONST_DECL_USING_P (decl))
2867 : : /* Let the clone hide the using-decl that introduced it. */
2868 : 301420 : binding->value = decl;
2869 : 184 : else if (name_independent_decl_p (decl))
2870 : : {
2871 : 63 : if (cxx_dialect < cxx26)
2872 : 48 : pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wc__26_extensions,
2873 : : "name-independent declarations only available with "
2874 : : "%<-std=c++2c%> or %<-std=gnu++2c%>");
2875 : 63 : binding->value = name_lookup::ambiguous (decl, binding->value);
2876 : : }
2877 : : else
2878 : : {
2879 : 121 : if (!error_operand_p (bval))
2880 : 121 : diagnose_name_conflict (decl, bval);
2881 : : ok = false;
2882 : : }
2883 : :
2884 : 635874 : return ok;
2885 : 317937 : }
2886 : :
2887 : : /* Diagnose a name conflict between DECL and BVAL.
2888 : :
2889 : : This is non-static so maybe_push_used_methods can use it and avoid changing
2890 : : the diagnostic for inherit/using4.C; otherwise it should not be used from
2891 : : outside this file. */
2892 : :
2893 : : void
2894 : 229 : diagnose_name_conflict (tree decl, tree bval)
2895 : : {
2896 : 229 : auto_diagnostic_group d;
2897 : 229 : if (TREE_CODE (decl) == TREE_CODE (bval)
2898 : 174 : && TREE_CODE (decl) != NAMESPACE_DECL
2899 : 168 : && !DECL_DECLARES_FUNCTION_P (decl)
2900 : 120 : && (TREE_CODE (decl) != TYPE_DECL
2901 : 21 : || DECL_ARTIFICIAL (decl) == DECL_ARTIFICIAL (bval))
2902 : 346 : && CP_DECL_CONTEXT (decl) == CP_DECL_CONTEXT (bval))
2903 : : {
2904 : 90 : if (concept_definition_p (decl))
2905 : 6 : error ("redeclaration of %q#D with different template parameters",
2906 : : decl);
2907 : : else
2908 : 75 : error ("redeclaration of %q#D", decl);
2909 : : }
2910 : : else
2911 : 148 : error ("%q#D conflicts with a previous declaration", decl);
2912 : :
2913 : 229 : inform (location_of (bval), "previous declaration %q#D", bval);
2914 : 229 : }
2915 : :
2916 : : /* Replace BINDING's current value on its scope's name list with
2917 : : NEWVAL. */
2918 : :
2919 : : static void
2920 : 109 : update_local_overload (cxx_binding *binding, tree newval)
2921 : : {
2922 : 109 : tree *d;
2923 : :
2924 : 124 : for (d = &binding->scope->names; ; d = &TREE_CHAIN (*d))
2925 : 124 : if (*d == binding->value)
2926 : : {
2927 : : /* Stitch new list node in. */
2928 : 66 : *d = tree_cons (DECL_NAME (*d), NULL_TREE, TREE_CHAIN (*d));
2929 : 66 : break;
2930 : : }
2931 : 58 : else if (TREE_CODE (*d) == TREE_LIST && TREE_VALUE (*d) == binding->value)
2932 : : break;
2933 : :
2934 : 109 : TREE_VALUE (*d) = newval;
2935 : 109 : }
2936 : :
2937 : : /* Compares the parameter-type-lists of ONE and TWO and
2938 : : returns false if they are different. If the DECLs are template
2939 : : functions, the return types and the template parameter lists are
2940 : : compared too (DR 565). */
2941 : :
2942 : : static bool
2943 : 3694847 : matching_fn_p (tree one, tree two)
2944 : : {
2945 : 3694847 : if (TREE_CODE (one) != TREE_CODE (two))
2946 : : return false;
2947 : :
2948 : 1874721 : if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (one)),
2949 : 1874721 : TYPE_ARG_TYPES (TREE_TYPE (two))))
2950 : : return false;
2951 : :
2952 : 99 : if (TREE_CODE (one) == TEMPLATE_DECL)
2953 : : {
2954 : : /* Compare template parms. */
2955 : 72 : if (!comp_template_parms (DECL_TEMPLATE_PARMS (one),
2956 : 36 : DECL_TEMPLATE_PARMS (two)))
2957 : : return false;
2958 : :
2959 : : /* And return type. */
2960 : 18 : if (!same_type_p (TREE_TYPE (TREE_TYPE (one)),
2961 : : TREE_TYPE (TREE_TYPE (two))))
2962 : : return false;
2963 : : }
2964 : :
2965 : 72 : if (!equivalently_constrained (one, two))
2966 : : return false;
2967 : :
2968 : : return true;
2969 : : }
2970 : :
2971 : : /* Push DECL into nonclass LEVEL BINDING or SLOT. OLD is the current
2972 : : binding value (possibly with anticipated builtins stripped).
2973 : : Diagnose conflicts and return updated decl. */
2974 : :
2975 : : static tree
2976 : 1103274021 : update_binding (cp_binding_level *level, cxx_binding *binding, tree *slot,
2977 : : tree old, tree decl, bool hiding = false)
2978 : : {
2979 : 1103274021 : tree old_type = NULL_TREE;
2980 : 1103274021 : bool hide_type = false;
2981 : 1103274021 : bool hide_value = false;
2982 : 1103274021 : bool name_independent_p = false;
2983 : :
2984 : 1103274021 : if (!slot)
2985 : : {
2986 : 770808207 : old_type = binding->type;
2987 : 770808207 : hide_type = HIDDEN_TYPE_BINDING_P (binding);
2988 : 770808207 : if (!old_type)
2989 : 770808204 : hide_value = hide_type, hide_type = false;
2990 : 770808207 : name_independent_p = name_independent_decl_p (decl);
2991 : : }
2992 : 332465814 : else if (STAT_HACK_P (*slot))
2993 : : {
2994 : 59 : old_type = STAT_TYPE (*slot);
2995 : 59 : hide_type = STAT_TYPE_HIDDEN_P (*slot);
2996 : 59 : hide_value = STAT_DECL_HIDDEN_P (*slot);
2997 : : }
2998 : :
2999 : 1103274021 : tree to_val = decl;
3000 : 1103274021 : tree to_type = old_type;
3001 : 1103274021 : bool local_overload = false;
3002 : :
3003 : 1103274021 : gcc_assert (!level || level->kind == sk_namespace ? !binding
3004 : : : level->kind != sk_class && !slot);
3005 : :
3006 : 1103274021 : if (old == error_mark_node)
3007 : 92069 : old = NULL_TREE;
3008 : 1103274021 : old = strip_using_decl (old);
3009 : :
3010 : 1103274021 : if (DECL_IMPLICIT_TYPEDEF_P (decl))
3011 : : {
3012 : : /* Pushing an artificial decl. We should not find another
3013 : : artificial decl here already -- lookup_elaborated_type will
3014 : : have already found it. */
3015 : 4939539 : gcc_checking_assert (!to_type
3016 : : && !(old && DECL_IMPLICIT_TYPEDEF_P (old)));
3017 : :
3018 : : if (old)
3019 : : {
3020 : : /* Put DECL into the type slot. */
3021 : : gcc_checking_assert (!to_type);
3022 : : hide_type = hiding;
3023 : : to_type = decl;
3024 : : to_val = old;
3025 : : }
3026 : : else
3027 : : hide_value = hiding;
3028 : :
3029 : 4939539 : goto done;
3030 : : }
3031 : :
3032 : 1098334482 : if (old && DECL_IMPLICIT_TYPEDEF_P (old))
3033 : : {
3034 : : /* OLD is an implicit typedef. Move it to to_type. */
3035 : 68298 : gcc_checking_assert (!to_type);
3036 : :
3037 : : to_type = old;
3038 : : hide_type = hide_value;
3039 : : old = NULL_TREE;
3040 : : hide_value = false;
3041 : : }
3042 : :
3043 : 1098334482 : if (DECL_DECLARES_FUNCTION_P (decl))
3044 : : {
3045 : 302243288 : if (!old)
3046 : : ;
3047 : 22739541 : else if (OVL_P (old))
3048 : : {
3049 : 604180788 : for (ovl_iterator iter (old); iter; ++iter)
3050 : : {
3051 : 292807592 : tree fn = *iter;
3052 : :
3053 : 292807592 : if (iter.using_p () && matching_fn_p (fn, decl))
3054 : : {
3055 : 33 : gcc_checking_assert (!iter.hidden_p ());
3056 : : /* If a function declaration in namespace scope or
3057 : : block scope has the same name and the same
3058 : : parameter-type- list (8.3.5) as a function
3059 : : introduced by a using-declaration, and the
3060 : : declarations do not declare the same function,
3061 : : the program is ill-formed. [namespace.udecl]/14 */
3062 : 33 : if (tree match = duplicate_decls (decl, fn, hiding))
3063 : 6 : return match;
3064 : : else
3065 : : /* FIXME: To preserve existing error behavior, we
3066 : : still push the decl. This might change. */
3067 : 27 : diagnose_name_conflict (decl, fn);
3068 : : }
3069 : : }
3070 : 22739535 : }
3071 : : else
3072 : 0 : goto conflict;
3073 : :
3074 : 302243282 : if (to_type != old_type
3075 : 38657 : && warn_shadow
3076 : 6 : && MAYBE_CLASS_TYPE_P (TREE_TYPE (to_type))
3077 : 302243288 : && !(DECL_IN_SYSTEM_HEADER (decl)
3078 : 0 : && DECL_IN_SYSTEM_HEADER (to_type)))
3079 : 6 : warning (OPT_Wshadow, "%q#D hides constructor for %q#D",
3080 : : decl, to_type);
3081 : :
3082 : 302243282 : local_overload = old && level && level->kind != sk_namespace;
3083 : 302243282 : to_val = ovl_insert (decl, old, -int (hiding));
3084 : : }
3085 : 796091194 : else if (old)
3086 : : {
3087 : 228 : if (name_independent_p)
3088 : 183 : to_val = name_lookup::ambiguous (decl, old);
3089 : 45 : else if (TREE_CODE (old) != TREE_CODE (decl))
3090 : : /* Different kinds of decls conflict. */
3091 : 0 : goto conflict;
3092 : 45 : else if (TREE_CODE (old) == TYPE_DECL)
3093 : : {
3094 : 3 : if (same_type_p (TREE_TYPE (old), TREE_TYPE (decl)))
3095 : : /* Two type decls to the same type. Do nothing. */
3096 : : return old;
3097 : : else
3098 : 0 : goto conflict;
3099 : : }
3100 : 42 : else if (TREE_CODE (old) == NAMESPACE_DECL)
3101 : : {
3102 : : /* Two maybe-aliased namespaces. If they're to the same target
3103 : : namespace, that's ok. */
3104 : 9 : if (ORIGINAL_NAMESPACE (old) != ORIGINAL_NAMESPACE (decl))
3105 : 6 : goto conflict;
3106 : :
3107 : : /* The new one must be an alias at this point. */
3108 : 3 : gcc_assert (DECL_NAMESPACE_ALIAS (decl));
3109 : : return old;
3110 : : }
3111 : 33 : else if (TREE_CODE (old) == VAR_DECL)
3112 : : {
3113 : 24 : if (tree match = duplicate_decls (decl, old))
3114 : : {
3115 : 9 : gcc_checking_assert (!hide_value && !hiding);
3116 : : return match;
3117 : : }
3118 : : else
3119 : 15 : goto conflict;
3120 : : }
3121 : : else
3122 : : {
3123 : 9 : conflict:
3124 : 30 : diagnose_name_conflict (decl, old);
3125 : 30 : to_val = NULL_TREE;
3126 : : }
3127 : : }
3128 : 796090966 : else if (hiding)
3129 : 25152 : hide_value = true;
3130 : :
3131 : 796065814 : done:
3132 : 1103274000 : if (to_val)
3133 : : {
3134 : 1103273970 : if (local_overload)
3135 : : {
3136 : 73 : gcc_checking_assert (binding->value && OVL_P (binding->value));
3137 : 73 : update_local_overload (binding, to_val);
3138 : : }
3139 : 1103273897 : else if (level
3140 : 1103273897 : && !(TREE_CODE (decl) == NAMESPACE_DECL
3141 : 791218 : && !DECL_NAMESPACE_ALIAS (decl)))
3142 : : /* Don't add namespaces here. They're done in
3143 : : push_namespace. */
3144 : 1102589363 : add_decl_to_level (level, decl);
3145 : :
3146 : 1103273970 : if (slot)
3147 : : {
3148 : 332465781 : if (STAT_HACK_P (*slot))
3149 : : {
3150 : 59 : STAT_TYPE (*slot) = to_type;
3151 : 59 : STAT_DECL (*slot) = to_val;
3152 : 59 : STAT_TYPE_HIDDEN_P (*slot) = hide_type;
3153 : 59 : STAT_DECL_HIDDEN_P (*slot) = hide_value;
3154 : : }
3155 : 332465722 : else if (to_type || hide_value)
3156 : : {
3157 : 134729 : *slot = stat_hack (to_val, to_type);
3158 : 134729 : STAT_TYPE_HIDDEN_P (*slot) = hide_type;
3159 : 134729 : STAT_DECL_HIDDEN_P (*slot) = hide_value;
3160 : : }
3161 : : else
3162 : : {
3163 : 332330993 : gcc_checking_assert (!hide_type);
3164 : 332330993 : *slot = to_val;
3165 : : }
3166 : : }
3167 : : else
3168 : : {
3169 : 770808189 : binding->type = to_type;
3170 : 770808189 : binding->value = to_val;
3171 : 770808189 : HIDDEN_TYPE_BINDING_P (binding) = hide_type || hide_value;
3172 : : }
3173 : : }
3174 : :
3175 : : return decl;
3176 : : }
3177 : :
3178 : : /* Table of identifiers to extern C declarations (or LISTS thereof). */
3179 : :
3180 : : static GTY(()) hash_table<named_decl_hash> *extern_c_decls;
3181 : :
3182 : : /* DECL has C linkage. If we have an existing instance, make sure the
3183 : : new one is compatible. Make sure it has the same exception
3184 : : specification [7.5, 7.6]. Add DECL to the map. */
3185 : :
3186 : : static void
3187 : 263796626 : check_extern_c_conflict (tree decl)
3188 : : {
3189 : : /* Ignore artificial or system header decls. */
3190 : 263796626 : if (DECL_ARTIFICIAL (decl) || DECL_IN_SYSTEM_HEADER (decl))
3191 : 263675172 : return;
3192 : :
3193 : : /* This only applies to decls at namespace scope. */
3194 : 121454 : if (!DECL_NAMESPACE_SCOPE_P (decl))
3195 : : return;
3196 : :
3197 : 121442 : if (!extern_c_decls)
3198 : 33966 : extern_c_decls = hash_table<named_decl_hash>::create_ggc (127);
3199 : :
3200 : 121442 : tree *slot = extern_c_decls
3201 : 121442 : ->find_slot_with_hash (DECL_NAME (decl),
3202 : 121442 : IDENTIFIER_HASH_VALUE (DECL_NAME (decl)), INSERT);
3203 : 121442 : if (tree old = *slot)
3204 : : {
3205 : 394 : if (TREE_CODE (old) == OVERLOAD)
3206 : 18 : old = OVL_FUNCTION (old);
3207 : :
3208 : 394 : int mismatch = 0;
3209 : 394 : if (DECL_CONTEXT (old) == DECL_CONTEXT (decl))
3210 : : ; /* If they're in the same context, we'll have already complained
3211 : : about a (possible) mismatch, when inserting the decl. */
3212 : 376 : else if (!decls_match (decl, old))
3213 : : mismatch = 1;
3214 : 355 : else if (TREE_CODE (decl) == FUNCTION_DECL
3215 : 698 : && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old)),
3216 : 343 : TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)),
3217 : : ce_normal))
3218 : : mismatch = -1;
3219 : 352 : else if (DECL_ASSEMBLER_NAME_SET_P (old))
3220 : 9 : SET_DECL_ASSEMBLER_NAME (decl, DECL_ASSEMBLER_NAME (old));
3221 : :
3222 : 9 : if (mismatch)
3223 : : {
3224 : 24 : auto_diagnostic_group d;
3225 : 24 : pedwarn (DECL_SOURCE_LOCATION (decl), 0,
3226 : : "conflicting C language linkage declaration %q#D", decl);
3227 : 24 : inform (DECL_SOURCE_LOCATION (old),
3228 : : "previous declaration %q#D", old);
3229 : 24 : if (mismatch < 0)
3230 : 3 : inform (DECL_SOURCE_LOCATION (decl),
3231 : : "due to different exception specifications");
3232 : 24 : }
3233 : : else
3234 : : {
3235 : 370 : if (old == *slot)
3236 : : /* The hash table expects OVERLOADS, so construct one with
3237 : : OLD as both the function and the chain. This allocate
3238 : : an excess OVERLOAD node, but it's rare to have multiple
3239 : : extern "C" decls of the same name. And we save
3240 : : complicating the hash table logic (which is used
3241 : : elsewhere). */
3242 : 364 : *slot = ovl_make (old, old);
3243 : :
3244 : 370 : slot = &OVL_CHAIN (*slot);
3245 : :
3246 : : /* Chain it on for c_linkage_binding's use. */
3247 : 370 : *slot = tree_cons (NULL_TREE, decl, *slot);
3248 : : }
3249 : : }
3250 : : else
3251 : 121048 : *slot = decl;
3252 : : }
3253 : :
3254 : : /* Returns a list of C-linkage decls with the name NAME. Used in
3255 : : c-family/c-pragma.cc to implement redefine_extname pragma. */
3256 : :
3257 : : tree
3258 : 18 : c_linkage_bindings (tree name)
3259 : : {
3260 : 18 : if (extern_c_decls)
3261 : 24 : if (tree *slot = extern_c_decls
3262 : 12 : ->find_slot_with_hash (name, IDENTIFIER_HASH_VALUE (name), NO_INSERT))
3263 : : {
3264 : 6 : tree result = *slot;
3265 : 6 : if (TREE_CODE (result) == OVERLOAD)
3266 : 3 : result = OVL_CHAIN (result);
3267 : 6 : return result;
3268 : : }
3269 : :
3270 : : return NULL_TREE;
3271 : : }
3272 : :
3273 : : /* Subroutine of check_local_shadow. */
3274 : :
3275 : : static void
3276 : 167 : inform_shadowed (tree shadowed)
3277 : : {
3278 : 167 : inform (DECL_SOURCE_LOCATION (shadowed),
3279 : : "shadowed declaration is here");
3280 : 167 : }
3281 : :
3282 : : /* DECL is being declared at a local scope. Emit suitable shadow
3283 : : warnings. */
3284 : :
3285 : : static tree
3286 : 770808207 : check_local_shadow (tree decl)
3287 : : {
3288 : : /* Don't complain about the parms we push and then pop
3289 : : while tentatively parsing a function declarator. */
3290 : 770808207 : if (TREE_CODE (decl) == PARM_DECL && !DECL_CONTEXT (decl))
3291 : : return NULL_TREE;
3292 : :
3293 : 557803403 : if (DECL_FUNCTION_SCOPE_P (decl))
3294 : : {
3295 : 354497627 : tree ctx = DECL_CONTEXT (decl);
3296 : 708995254 : if (DECL_CLONED_FUNCTION_P (ctx)
3297 : 333067518 : || DECL_TEMPLATE_INSTANTIATED (ctx)
3298 : 285112566 : || (DECL_LANG_SPECIFIC (ctx)
3299 : 285112566 : && DECL_DEFAULTED_FN (ctx))
3300 : 656427624 : || (LAMBDA_FUNCTION_P (ctx)
3301 : 2843587 : && LAMBDA_EXPR_REGEN_INFO (CLASSTYPE_LAMBDA_EXPR
3302 : : (DECL_CONTEXT (ctx)))))
3303 : : /* It suffices to check shadowing only when actually parsing.
3304 : : So punt for clones, instantiations, defaulted functions and
3305 : : regenerated lambdas. This optimization helps reduce lazy
3306 : : loading cascades with modules. */
3307 : : return NULL_TREE;
3308 : : }
3309 : :
3310 : 486714339 : tree old = NULL_TREE;
3311 : 486714339 : cp_binding_level *old_scope = NULL;
3312 : 486714339 : if (cxx_binding *binding = outer_binding (DECL_NAME (decl), NULL, true))
3313 : : {
3314 : 1302142 : old = binding->value;
3315 : 1302142 : old_scope = binding->scope;
3316 : : }
3317 : :
3318 : 1302142 : if (old
3319 : 1302142 : && (TREE_CODE (old) == PARM_DECL
3320 : 577287 : || VAR_P (old)
3321 : 147429 : || (TREE_CODE (old) == TYPE_DECL
3322 : 87597 : && (!DECL_ARTIFICIAL (old)
3323 : 57305 : || TREE_CODE (decl) == TYPE_DECL)))
3324 : 1242221 : && DECL_FUNCTION_SCOPE_P (old)
3325 : 2457337 : && (!DECL_ARTIFICIAL (decl)
3326 : 979642 : || is_capture_proxy (decl)
3327 : 230995 : || DECL_IMPLICIT_TYPEDEF_P (decl)
3328 : 230965 : || (VAR_P (decl) && DECL_ANON_UNION_VAR_P (decl))))
3329 : : {
3330 : : /* DECL shadows a local thing possibly of interest. */
3331 : :
3332 : : /* DR 2211: check that captures and parameters
3333 : : do not have the same name. */
3334 : 924236 : if (is_capture_proxy (decl))
3335 : : {
3336 : 748647 : if (current_lambda_expr ()
3337 : 748647 : && DECL_CONTEXT (old) == lambda_function (current_lambda_expr ())
3338 : 39 : && TREE_CODE (old) == PARM_DECL
3339 : 748668 : && DECL_NAME (decl) != this_identifier)
3340 : 21 : error_at (DECL_SOURCE_LOCATION (old),
3341 : : "lambda parameter %qD "
3342 : : "previously declared as a capture", old);
3343 : 748647 : return NULL_TREE;
3344 : : }
3345 : : /* Don't complain if it's from an enclosing function. */
3346 : 175589 : else if (DECL_CONTEXT (old) == current_function_decl
3347 : 160814 : && TREE_CODE (decl) != PARM_DECL
3348 : 336403 : && TREE_CODE (old) == PARM_DECL)
3349 : : {
3350 : : /* Go to where the parms should be and see if we find
3351 : : them there. */
3352 : 10141 : cp_binding_level *b = current_binding_level->level_chain;
3353 : :
3354 : 10141 : if (in_function_try_handler && b->kind == sk_catch)
3355 : 39 : b = b->level_chain;
3356 : :
3357 : : /* Skip artificially added scopes which aren't present
3358 : : in the C++ standard, e.g. for function-try-block or
3359 : : ctor/dtor cleanups. */
3360 : 10222 : while (b->artificial)
3361 : 81 : b = b->level_chain;
3362 : :
3363 : : /* [basic.scope.param] A parameter name shall not be redeclared
3364 : : in the outermost block of the function definition. */
3365 : 10141 : if (b->kind == sk_function_parms)
3366 : : {
3367 : 114 : if (name_independent_decl_p (decl))
3368 : : return old;
3369 : :
3370 : 96 : auto_diagnostic_group d;
3371 : 96 : bool emit = true;
3372 : 96 : if (DECL_EXTERNAL (decl))
3373 : 40 : emit = pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wpedantic,
3374 : : "declaration of %q#D shadows a parameter",
3375 : : decl);
3376 : : else
3377 : 56 : error_at (DECL_SOURCE_LOCATION (decl),
3378 : : "declaration of %q#D shadows a parameter", decl);
3379 : 96 : if (emit)
3380 : 96 : inform (DECL_SOURCE_LOCATION (old),
3381 : : "%q#D previously declared here", old);
3382 : 96 : return NULL_TREE;
3383 : 96 : }
3384 : : }
3385 : :
3386 : : /* The local structure or class can't use parameters of
3387 : : the containing function anyway. */
3388 : 175475 : if (DECL_CONTEXT (old) != current_function_decl)
3389 : : {
3390 : 14775 : for (cp_binding_level *scope = current_binding_level;
3391 : 37496 : scope != old_scope; scope = scope->level_chain)
3392 : 35203 : if (scope->kind == sk_class
3393 : 52349 : && !LAMBDA_TYPE_P (scope->this_entity))
3394 : : return NULL_TREE;
3395 : : }
3396 : : /* Error if redeclaring a local declared in a
3397 : : init-statement or in the condition of an if or
3398 : : switch statement when the new declaration is in the
3399 : : outermost block of the controlled statement.
3400 : : Redeclaring a variable from a for or while condition is
3401 : : detected elsewhere. */
3402 : 160700 : else if (VAR_P (old)
3403 : 150166 : && old_scope == current_binding_level->level_chain
3404 : 1741 : && (old_scope->kind == sk_cond || old_scope->kind == sk_for))
3405 : : {
3406 : 145 : if (name_independent_decl_p (decl))
3407 : : return old;
3408 : :
3409 : 109 : auto_diagnostic_group d;
3410 : 109 : bool emit = true;
3411 : 109 : if (DECL_EXTERNAL (decl))
3412 : 48 : emit = pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wpedantic,
3413 : : "redeclaration of %q#D", decl);
3414 : : else
3415 : 61 : error_at (DECL_SOURCE_LOCATION (decl),
3416 : : "redeclaration of %q#D", decl);
3417 : 109 : if (emit)
3418 : 109 : inform (DECL_SOURCE_LOCATION (old),
3419 : : "%q#D previously declared here", old);
3420 : 109 : return NULL_TREE;
3421 : 109 : }
3422 : : /* C++11:
3423 : : 3.3.3/3: The name declared in an exception-declaration (...)
3424 : : shall not be redeclared in the outermost block of the handler.
3425 : : 3.3.3/2: A parameter name shall not be redeclared (...) in
3426 : : the outermost block of any handler associated with a
3427 : : function-try-block. */
3428 : 160555 : else if (TREE_CODE (old) == VAR_DECL
3429 : 150021 : && old_scope == current_binding_level->level_chain
3430 : 1596 : && old_scope->kind == sk_catch)
3431 : : {
3432 : 18 : if (name_independent_decl_p (decl))
3433 : : return old;
3434 : :
3435 : 15 : auto_diagnostic_group d;
3436 : 15 : bool emit;
3437 : 15 : if (DECL_EXTERNAL (decl))
3438 : 6 : emit = pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wpedantic,
3439 : : "redeclaration of %q#D", decl);
3440 : : else
3441 : 9 : emit = permerror (DECL_SOURCE_LOCATION (decl),
3442 : : "redeclaration of %q#D", decl);
3443 : 15 : if (emit)
3444 : 15 : inform (DECL_SOURCE_LOCATION (old),
3445 : : "%q#D previously declared here", old);
3446 : 15 : return NULL_TREE;
3447 : 15 : }
3448 : :
3449 : : /* Don't emit -Wshadow* warnings for name-independent decls. */
3450 : 162830 : if (name_independent_decl_p (decl) || name_independent_decl_p (old))
3451 : : return NULL_TREE;
3452 : :
3453 : : /* If '-Wshadow=compatible-local' is specified without other
3454 : : -Wshadow= flags, we will warn only when the type of the
3455 : : shadowing variable (DECL) can be converted to that of the
3456 : : shadowed parameter (OLD_LOCAL). The reason why we only check
3457 : : if DECL's type can be converted to OLD_LOCAL's type (but not the
3458 : : other way around) is because when users accidentally shadow a
3459 : : parameter, more than often they would use the variable
3460 : : thinking (mistakenly) it's still the parameter. It would be
3461 : : rare that users would use the variable in the place that
3462 : : expects the parameter but thinking it's a new decl.
3463 : : If either object is a TYPE_DECL, '-Wshadow=compatible-local'
3464 : : warns regardless of whether one of the types involved
3465 : : is a subclass of the other, since that is never okay. */
3466 : :
3467 : 162755 : enum opt_code warning_code;
3468 : 162755 : if (warn_shadow)
3469 : : warning_code = OPT_Wshadow;
3470 : 162693 : else if ((TREE_CODE (decl) == TYPE_DECL)
3471 : 162693 : ^ (TREE_CODE (old) == TYPE_DECL))
3472 : : /* If exactly one is a type, they aren't compatible. */
3473 : : warning_code = OPT_Wshadow_local;
3474 : 162672 : else if ((TREE_TYPE (old)
3475 : 162672 : && TREE_TYPE (decl)
3476 : 162669 : && same_type_p (TREE_TYPE (old), TREE_TYPE (decl)))
3477 : 31530 : || TREE_CODE (decl) == TYPE_DECL
3478 : 31524 : || TREE_CODE (old) == TYPE_DECL
3479 : 194196 : || (!dependent_type_p (TREE_TYPE (decl))
3480 : 12103 : && !dependent_type_p (TREE_TYPE (old))
3481 : : /* If the new decl uses auto, we don't yet know
3482 : : its type (the old type cannot be using auto
3483 : : at this point, without also being
3484 : : dependent). This is an indication we're
3485 : : (now) doing the shadow checking too
3486 : : early. */
3487 : 12088 : && !type_uses_auto (TREE_TYPE (decl))
3488 : 11930 : && can_convert_arg (TREE_TYPE (old), TREE_TYPE (decl),
3489 : : decl, LOOKUP_IMPLICIT, tf_none)))
3490 : : warning_code = OPT_Wshadow_compatible_local;
3491 : : else
3492 : : warning_code = OPT_Wshadow_local;
3493 : :
3494 : 162755 : const char *msg;
3495 : 162755 : if (TREE_CODE (old) == PARM_DECL)
3496 : : msg = "declaration of %q#D shadows a parameter";
3497 : 150839 : else if (is_capture_proxy (old))
3498 : : msg = "declaration of %qD shadows a lambda capture";
3499 : : else
3500 : 150579 : msg = "declaration of %qD shadows a previous local";
3501 : :
3502 : 162755 : auto_diagnostic_group d;
3503 : 162755 : if (warning_at (DECL_SOURCE_LOCATION (decl), warning_code, msg, decl))
3504 : 110 : inform_shadowed (old);
3505 : 162755 : return NULL_TREE;
3506 : 162755 : }
3507 : :
3508 : 485790103 : if (!warn_shadow)
3509 : : return NULL_TREE;
3510 : :
3511 : : /* Don't emit -Wshadow for name-independent decls. */
3512 : 622 : if (name_independent_decl_p (decl))
3513 : : return NULL_TREE;
3514 : :
3515 : : /* Don't warn for artificial things that are not implicit typedefs. */
3516 : 544 : if (DECL_ARTIFICIAL (decl) && !DECL_IMPLICIT_TYPEDEF_P (decl))
3517 : : return NULL_TREE;
3518 : :
3519 : 338 : if (nonlambda_method_basetype ())
3520 : 93 : if (tree member = lookup_member (current_nonlambda_class_type (),
3521 : 93 : DECL_NAME (decl), /*protect=*/0,
3522 : : /*want_type=*/false, tf_warning_or_error))
3523 : : {
3524 : 33 : member = MAYBE_BASELINK_FUNCTIONS (member);
3525 : :
3526 : : /* Warn if a variable shadows a non-function, or the variable
3527 : : is a function or a pointer-to-function. */
3528 : 24 : if ((!OVL_P (member)
3529 : 9 : || TREE_CODE (decl) == FUNCTION_DECL
3530 : 9 : || (TREE_TYPE (decl)
3531 : 6 : && (TYPE_PTRFN_P (TREE_TYPE (decl))
3532 : 6 : || TYPE_PTRMEMFUNC_P (TREE_TYPE (decl)))))
3533 : 60 : && !warning_suppressed_p (decl, OPT_Wshadow))
3534 : : {
3535 : 27 : auto_diagnostic_group d;
3536 : 27 : if (warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wshadow,
3537 : : "declaration of %qD shadows a member of %qT",
3538 : : decl, current_nonlambda_class_type ())
3539 : 27 : && DECL_P (member))
3540 : : {
3541 : 27 : inform_shadowed (member);
3542 : 27 : suppress_warning (decl, OPT_Wshadow);
3543 : : }
3544 : 27 : }
3545 : 33 : return NULL_TREE;
3546 : : }
3547 : :
3548 : : /* Now look for a namespace shadow. */
3549 : 305 : old = find_namespace_value (current_namespace, DECL_NAME (decl));
3550 : 305 : if (old
3551 : 75 : && (VAR_P (old)
3552 : 51 : || (TREE_CODE (old) == TYPE_DECL
3553 : 15 : && (!DECL_ARTIFICIAL (old)
3554 : 9 : || TREE_CODE (decl) == TYPE_DECL)))
3555 : 33 : && !DECL_EXTERNAL (decl)
3556 : 30 : && !instantiating_current_function_p ()
3557 : 335 : && !warning_suppressed_p (decl, OPT_Wshadow))
3558 : : /* XXX shadow warnings in outer-more namespaces */
3559 : : {
3560 : 30 : auto_diagnostic_group d;
3561 : 30 : if (warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wshadow,
3562 : : "declaration of %qD shadows a global declaration",
3563 : : decl))
3564 : : {
3565 : 30 : inform_shadowed (old);
3566 : 30 : suppress_warning (decl, OPT_Wshadow);
3567 : : }
3568 : 30 : return NULL_TREE;
3569 : 30 : }
3570 : :
3571 : : return NULL_TREE;
3572 : : }
3573 : :
3574 : : /* DECL is being pushed inside function CTX. Set its context, if
3575 : : needed. */
3576 : :
3577 : : static void
3578 : 345996681 : set_decl_context_in_fn (tree ctx, tree decl)
3579 : : {
3580 : 345996681 : if (TREE_CODE (decl) == FUNCTION_DECL
3581 : 345996681 : || (VAR_P (decl) && DECL_EXTERNAL (decl)))
3582 : : /* Make sure local externs are marked as such. OMP UDRs really
3583 : : are nested functions. */
3584 : 36448 : gcc_checking_assert (DECL_LOCAL_DECL_P (decl)
3585 : : && (DECL_NAMESPACE_SCOPE_P (decl)
3586 : : || (TREE_CODE (decl) == FUNCTION_DECL
3587 : : && DECL_OMP_DECLARE_REDUCTION_P (decl))));
3588 : :
3589 : 345996681 : if (!DECL_CONTEXT (decl)
3590 : : /* When parsing the parameter list of a function declarator,
3591 : : don't set DECL_CONTEXT to an enclosing function. */
3592 : 346815961 : && !(TREE_CODE (decl) == PARM_DECL
3593 : 819280 : && parsing_function_declarator ()))
3594 : 79074373 : DECL_CONTEXT (decl) = ctx;
3595 : 345996681 : }
3596 : :
3597 : : /* DECL is a local extern decl. Find or create the namespace-scope
3598 : : decl that it aliases. Also, determines the linkage of DECL. */
3599 : :
3600 : : void
3601 : 36140 : push_local_extern_decl_alias (tree decl)
3602 : : {
3603 : 36140 : if (dependent_type_p (TREE_TYPE (decl))
3604 : 36140 : || (processing_template_decl
3605 : 15738 : && VAR_P (decl)
3606 : 50 : && CP_DECL_THREAD_LOCAL_P (decl)))
3607 : : return;
3608 : : /* EH specs were not part of the function type prior to c++17, but
3609 : : we still can't go pushing dependent eh specs into the namespace. */
3610 : 36060 : if (cxx_dialect < cxx17
3611 : 2367 : && TREE_CODE (decl) == FUNCTION_DECL
3612 : 38052 : && (value_dependent_expression_p
3613 : 1992 : (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)))))
3614 : : return;
3615 : :
3616 : 36059 : gcc_checking_assert (!DECL_LANG_SPECIFIC (decl)
3617 : : || !DECL_TEMPLATE_INFO (decl));
3618 : 36059 : if (DECL_LANG_SPECIFIC (decl) && DECL_LOCAL_DECL_ALIAS (decl))
3619 : : /* We're instantiating a non-dependent local decl, it already
3620 : : knows the alias. */
3621 : : return;
3622 : :
3623 : 35624 : tree alias = NULL_TREE;
3624 : :
3625 : 35624 : if (DECL_SIZE (decl) && !TREE_CONSTANT (DECL_SIZE (decl)))
3626 : : /* Do not let a VLA creep into a namespace. Diagnostic will be
3627 : : emitted in layout_var_decl later. */
3628 : 3 : alias = error_mark_node;
3629 : : else
3630 : : {
3631 : : /* First look for a decl that matches. */
3632 : 35621 : tree ns = CP_DECL_CONTEXT (decl);
3633 : 35621 : tree binding = find_namespace_value (ns, DECL_NAME (decl));
3634 : :
3635 : 35621 : if (binding && TREE_CODE (binding) != TREE_LIST)
3636 : 888 : for (ovl_iterator iter (binding); iter; ++iter)
3637 : 620 : if (decls_match (decl, *iter, /*record_versions*/false))
3638 : : {
3639 : 427 : alias = *iter;
3640 : 427 : if (!validate_constexpr_redeclaration (alias, decl))
3641 : 12 : return;
3642 : : break;
3643 : : }
3644 : :
3645 : 520 : if (!alias)
3646 : : {
3647 : : /* No existing namespace-scope decl. Make one. */
3648 : 35194 : alias = copy_decl (decl);
3649 : 35194 : if (TREE_CODE (alias) == FUNCTION_DECL)
3650 : : {
3651 : : /* Recontextualize the parms. */
3652 : 34387 : for (tree *chain = &DECL_ARGUMENTS (alias);
3653 : 38838 : *chain; chain = &DECL_CHAIN (*chain))
3654 : : {
3655 : 4451 : *chain = copy_decl (*chain);
3656 : 4451 : DECL_CONTEXT (*chain) = alias;
3657 : : }
3658 : :
3659 : 34387 : tree type = TREE_TYPE (alias);
3660 : 34387 : for (tree args = TYPE_ARG_TYPES (type);
3661 : 77372 : args; args = TREE_CHAIN (args))
3662 : 43024 : if (TREE_PURPOSE (args))
3663 : : {
3664 : : /* There are default args. Lose them. */
3665 : 39 : tree nargs = NULL_TREE;
3666 : 39 : tree *chain = &nargs;
3667 : 39 : for (args = TYPE_ARG_TYPES (type);
3668 : 99 : args; args = TREE_CHAIN (args))
3669 : 99 : if (args == void_list_node)
3670 : : {
3671 : 39 : *chain = args;
3672 : 39 : break;
3673 : : }
3674 : : else
3675 : : {
3676 : 60 : *chain
3677 : 60 : = build_tree_list (NULL_TREE, TREE_VALUE (args));
3678 : 60 : chain = &TREE_CHAIN (*chain);
3679 : : }
3680 : :
3681 : 39 : tree fn_type = build_function_type (TREE_TYPE (type), nargs);
3682 : :
3683 : 39 : fn_type = apply_memfn_quals
3684 : 39 : (fn_type, type_memfn_quals (type));
3685 : :
3686 : 39 : fn_type = build_cp_fntype_variant
3687 : 39 : (fn_type, type_memfn_rqual (type),
3688 : 39 : TYPE_RAISES_EXCEPTIONS (type),
3689 : 39 : TYPE_HAS_LATE_RETURN_TYPE (type));
3690 : :
3691 : 39 : TREE_TYPE (alias) = fn_type;
3692 : 39 : break;
3693 : : }
3694 : : }
3695 : :
3696 : : /* This is the real thing. */
3697 : 35194 : DECL_LOCAL_DECL_P (alias) = false;
3698 : :
3699 : : /* Expected default linkage is from the namespace. */
3700 : 35194 : TREE_PUBLIC (alias) = TREE_PUBLIC (ns);
3701 : 35194 : push_nested_namespace (ns);
3702 : 35194 : alias = pushdecl (alias, /* hiding= */true);
3703 : 35194 : pop_nested_namespace (ns);
3704 : 35194 : if (VAR_P (decl)
3705 : 807 : && CP_DECL_THREAD_LOCAL_P (decl)
3706 : 35215 : && alias != error_mark_node)
3707 : 18 : set_decl_tls_model (alias, DECL_TLS_MODEL (decl));
3708 : :
3709 : : /* Adjust visibility. */
3710 : 35194 : determine_visibility (alias);
3711 : : }
3712 : : }
3713 : :
3714 : 35612 : retrofit_lang_decl (decl);
3715 : 35612 : DECL_LOCAL_DECL_ALIAS (decl) = alias;
3716 : : }
3717 : :
3718 : : /* If DECL has non-internal linkage, and we have a module vector,
3719 : : record it in the appropriate slot. We have already checked for
3720 : : duplicates. */
3721 : :
3722 : : static void
3723 : 271693 : maybe_record_mergeable_decl (tree *slot, tree name, tree decl)
3724 : : {
3725 : 271693 : if (TREE_CODE (*slot) != BINDING_VECTOR)
3726 : : return;
3727 : :
3728 : 13 : if (!TREE_PUBLIC (CP_DECL_CONTEXT (decl)))
3729 : : /* Member of internal namespace. */
3730 : : return;
3731 : :
3732 : 13 : tree not_tmpl = STRIP_TEMPLATE (decl);
3733 : 13 : if ((TREE_CODE (not_tmpl) == FUNCTION_DECL
3734 : 0 : || VAR_P (not_tmpl))
3735 : 13 : && DECL_THIS_STATIC (not_tmpl))
3736 : : /* Internal linkage. */
3737 : : return;
3738 : :
3739 : 13 : bool is_attached = (DECL_LANG_SPECIFIC (not_tmpl)
3740 : 26 : && DECL_MODULE_ATTACH_P (not_tmpl));
3741 : : tree *gslot = get_fixed_binding_slot
3742 : 13 : (slot, name, is_attached ? BINDING_SLOT_PARTITION : BINDING_SLOT_GLOBAL,
3743 : : true);
3744 : :
3745 : 13 : if (!is_attached)
3746 : : {
3747 : 13 : binding_slot &orig
3748 : 13 : = BINDING_VECTOR_CLUSTER (*slot, 0).slots[BINDING_SLOT_CURRENT];
3749 : :
3750 : 13 : if (!STAT_HACK_P (tree (orig)))
3751 : 5 : orig = stat_hack (tree (orig));
3752 : :
3753 : 13 : MODULE_BINDING_GLOBAL_P (tree (orig)) = true;
3754 : : }
3755 : :
3756 : 13 : add_mergeable_namespace_entity (gslot, decl);
3757 : : }
3758 : :
3759 : : /* DECL is being pushed. Check whether it hides or ambiguates
3760 : : something seen as an import. This include decls seen in our own
3761 : : interface, which is OK. Also, check for merging a
3762 : : global/partition decl. */
3763 : :
3764 : : static tree
3765 : 392 : check_module_override (tree decl, tree mvec, bool hiding,
3766 : : tree scope, tree name)
3767 : : {
3768 : 392 : tree match = NULL_TREE;
3769 : 392 : bitmap imports = get_import_bitmap ();
3770 : 392 : binding_cluster *cluster = BINDING_VECTOR_CLUSTER_BASE (mvec);
3771 : 392 : unsigned ix = BINDING_VECTOR_NUM_CLUSTERS (mvec);
3772 : :
3773 : 392 : tree nontmpl = STRIP_TEMPLATE (decl);
3774 : 760 : bool attached = DECL_LANG_SPECIFIC (nontmpl) && DECL_MODULE_ATTACH_P (nontmpl);
3775 : :
3776 : : /* For deduction guides we don't do normal name lookup, but rather consider
3777 : : any reachable declaration, so we should check for overriding here too. */
3778 : 392 : bool any_reachable = deduction_guide_p (decl);
3779 : :
3780 : 392 : if (BINDING_VECTOR_SLOTS_PER_CLUSTER == BINDING_SLOTS_FIXED)
3781 : : {
3782 : 392 : cluster++;
3783 : 392 : ix--;
3784 : : }
3785 : :
3786 : 579 : for (; ix--; cluster++)
3787 : 995 : for (unsigned jx = 0; jx != BINDING_VECTOR_SLOTS_PER_CLUSTER; jx++)
3788 : : {
3789 : : /* Are we importing this module? */
3790 : 808 : if (cluster->indices[jx].span != 1)
3791 : 34 : continue;
3792 : 774 : if (!cluster->indices[jx].base)
3793 : 392 : continue;
3794 : 391 : if (!any_reachable
3795 : 382 : && !bitmap_bit_p (imports, cluster->indices[jx].base))
3796 : 9 : continue;
3797 : : /* Is it loaded? */
3798 : 373 : if (cluster->slots[jx].is_lazy ())
3799 : : {
3800 : 1 : gcc_assert (cluster->indices[jx].span == 1);
3801 : 1 : lazy_load_binding (cluster->indices[jx].base,
3802 : : scope, name, &cluster->slots[jx]);
3803 : : }
3804 : 373 : tree bind = cluster->slots[jx];
3805 : 373 : if (!bind)
3806 : : /* Errors could cause there to be nothing. */
3807 : 0 : continue;
3808 : :
3809 : 373 : tree type = NULL_TREE;
3810 : 373 : if (STAT_HACK_P (bind))
3811 : : {
3812 : : /* If there was a matching STAT_TYPE here then xref_tag
3813 : : should have found it, but we need to check anyway because
3814 : : a conflicting using-declaration may exist. */
3815 : 358 : if (any_reachable)
3816 : : {
3817 : 12 : type = STAT_TYPE (bind);
3818 : 12 : bind = STAT_DECL (bind);
3819 : : }
3820 : : else
3821 : : {
3822 : 346 : if (STAT_TYPE_VISIBLE_P (bind))
3823 : 123 : type = STAT_TYPE (bind);
3824 : 346 : bind = STAT_VISIBLE (bind);
3825 : : }
3826 : : }
3827 : :
3828 : 358 : if (type)
3829 : : {
3830 : 3 : match = duplicate_decls (decl, strip_using_decl (type), hiding);
3831 : 3 : if (match)
3832 : 0 : goto matched;
3833 : : }
3834 : :
3835 : 474 : for (ovl_iterator iter (strip_using_decl (bind)); iter; ++iter)
3836 : : {
3837 : 281 : match = duplicate_decls (decl, *iter, hiding);
3838 : 281 : if (match)
3839 : 220 : goto matched;
3840 : : }
3841 : : }
3842 : :
3843 : 172 : if (TREE_PUBLIC (scope) && TREE_PUBLIC (STRIP_TEMPLATE (decl))
3844 : : /* Namespaces are dealt with specially in
3845 : : make_namespace_finish. */
3846 : 332 : && !(TREE_CODE (decl) == NAMESPACE_DECL && !DECL_NAMESPACE_ALIAS (decl)))
3847 : : {
3848 : : /* Look in the appropriate mergeable decl slot. */
3849 : 148 : tree mergeable = NULL_TREE;
3850 : 148 : if (attached)
3851 : 24 : mergeable = BINDING_VECTOR_CLUSTER (mvec, BINDING_SLOT_PARTITION
3852 : : / BINDING_VECTOR_SLOTS_PER_CLUSTER)
3853 : 12 : .slots[BINDING_SLOT_PARTITION % BINDING_VECTOR_SLOTS_PER_CLUSTER];
3854 : : else
3855 : 136 : mergeable = BINDING_VECTOR_CLUSTER (mvec, 0).slots[BINDING_SLOT_GLOBAL];
3856 : :
3857 : 327 : for (ovl_iterator iter (mergeable); iter; ++iter)
3858 : : {
3859 : 155 : match = duplicate_decls (decl, *iter, hiding);
3860 : 155 : if (match)
3861 : 46 : goto matched;
3862 : : }
3863 : : }
3864 : :
3865 : : return NULL_TREE;
3866 : :
3867 : 266 : matched:
3868 : 266 : if (match != error_mark_node)
3869 : : {
3870 : 224 : if (attached)
3871 : 117 : BINDING_VECTOR_PARTITION_DUPS_P (mvec) = true;
3872 : : else
3873 : 107 : BINDING_VECTOR_GLOBAL_DUPS_P (mvec) = true;
3874 : : }
3875 : :
3876 : : return match;
3877 : : }
3878 : :
3879 : : /* Record DECL as belonging to the current lexical scope. Check for
3880 : : errors (such as an incompatible declaration for the same name
3881 : : already seen in the same scope).
3882 : :
3883 : : The new binding is hidden if HIDING is true (an anticipated builtin
3884 : : or hidden friend).
3885 : :
3886 : : Returns either DECL or an old decl for the same name. If an old
3887 : : decl is returned, it may have been smashed to agree with what DECL
3888 : : says. */
3889 : :
3890 : : tree
3891 : 1137063392 : pushdecl (tree decl, bool hiding)
3892 : : {
3893 : 1137063392 : auto_cond_timevar tv (TV_NAME_LOOKUP);
3894 : :
3895 : 1137063392 : if (decl == error_mark_node)
3896 : : return error_mark_node;
3897 : :
3898 : 1137063386 : if (!DECL_TEMPLATE_PARM_P (decl) && current_function_decl && !hiding)
3899 : 345996681 : set_decl_context_in_fn (current_function_decl, decl);
3900 : :
3901 : : /* The binding level we will be pushing into. During local class
3902 : : pushing, we want to push to the containing scope. */
3903 : 1137063386 : cp_binding_level *level = current_binding_level;
3904 : 1137063386 : while (level->kind == sk_class
3905 : 1137063579 : || level->kind == sk_cleanup)
3906 : 193 : level = level->level_chain;
3907 : :
3908 : : /* An anonymous namespace has a NULL DECL_NAME, but we still want to
3909 : : insert it. Other NULL-named decls, not so much. */
3910 : 1137063386 : tree name = DECL_NAME (decl);
3911 : 2250315602 : if (name ? !IDENTIFIER_ANON_P (name) : TREE_CODE (decl) == NAMESPACE_DECL)
3912 : : {
3913 : 1111790971 : cxx_binding *binding = NULL; /* Local scope binding. */
3914 : 1111790971 : tree ns = NULL_TREE; /* Searched namespace. */
3915 : 1111790971 : tree *slot = NULL; /* Binding slot in namespace. */
3916 : 1111790971 : tree *mslot = NULL; /* Current module slot in namespace. */
3917 : 1111790971 : tree old = NULL_TREE;
3918 : 1111790971 : bool name_independent_p = false;
3919 : 1111790971 : bool name_independent_diagnosed_p = false;
3920 : :
3921 : 1111790971 : if (level->kind == sk_namespace)
3922 : : {
3923 : : /* We look in the decl's namespace for an existing
3924 : : declaration, even though we push into the current
3925 : : namespace. */
3926 : 681960838 : ns = (DECL_NAMESPACE_SCOPE_P (decl)
3927 : 681960838 : ? CP_DECL_CONTEXT (decl) : current_namespace);
3928 : : /* Create the binding, if this is current namespace, because
3929 : : that's where we'll be pushing anyway. */
3930 : 340980419 : slot = find_namespace_slot (ns, name, ns == current_namespace);
3931 : 340980419 : if (slot)
3932 : : {
3933 : 681960772 : mslot = get_fixed_binding_slot (slot, name, BINDING_SLOT_CURRENT,
3934 : 340980386 : ns == current_namespace);
3935 : 340980386 : old = MAYBE_STAT_DECL (*mslot);
3936 : : }
3937 : : }
3938 : : else
3939 : : {
3940 : 770810552 : binding = find_local_binding (level, name);
3941 : 770810552 : if (binding)
3942 : 2682 : old = binding->value;
3943 : 770810552 : name_independent_p = name_independent_decl_p (decl);
3944 : : }
3945 : :
3946 : 1111790971 : if (old == error_mark_node)
3947 : 92069 : old = NULL_TREE;
3948 : :
3949 : 1111790971 : tree oldi, oldn;
3950 : 1134722766 : for (oldi = old; oldi; oldi = oldn)
3951 : : {
3952 : 31448694 : if (TREE_CODE (oldi) == TREE_LIST)
3953 : : {
3954 : 84 : gcc_checking_assert (level->kind != sk_namespace
3955 : : && name_independent_decl_p
3956 : : (TREE_VALUE (old)));
3957 : 42 : oldn = TREE_CHAIN (oldi);
3958 : 42 : oldi = TREE_VALUE (oldi);
3959 : : }
3960 : : else
3961 : : oldn = NULL_TREE;
3962 : 637282908 : for (ovl_iterator iter (oldi); iter; ++iter)
3963 : 313556306 : if (iter.using_p ())
3964 : : ; /* Ignore using decls here. */
3965 : 310204380 : else if (iter.hidden_p ()
3966 : 60062827 : && TREE_CODE (*iter) == FUNCTION_DECL
3967 : 41107005 : && DECL_LANG_SPECIFIC (*iter)
3968 : 351311385 : && DECL_MODULE_IMPORT_P (*iter))
3969 : : ; /* An undeclared builtin imported from elsewhere. */
3970 : 310204377 : else if (name_independent_p)
3971 : : {
3972 : : /* Ignore name-independent declarations. */
3973 : 180 : if (cxx_dialect < cxx26 && !name_independent_diagnosed_p)
3974 : 112 : pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wc__26_extensions,
3975 : : "name-independent declarations only available with "
3976 : : "%<-std=c++2c%> or %<-std=gnu++2c%>");
3977 : : name_independent_diagnosed_p = true;
3978 : : }
3979 : 620408394 : else if (tree match
3980 : 310204197 : = duplicate_decls (decl, *iter, hiding, iter.hidden_p ()))
3981 : : {
3982 : 8516899 : if (match == error_mark_node)
3983 : : ;
3984 : 8516016 : else if (TREE_CODE (match) == TYPE_DECL)
3985 : 21300 : gcc_checking_assert (REAL_IDENTIFIER_TYPE_VALUE (name)
3986 : : == (level->kind == sk_namespace
3987 : : ? NULL_TREE : TREE_TYPE (match)));
3988 : 8494716 : else if (iter.hidden_p () && !hiding)
3989 : : {
3990 : : /* Unhiding a previously hidden decl. */
3991 : 3747013 : tree head = iter.reveal_node (oldi);
3992 : 3747013 : if (head != oldi)
3993 : : {
3994 : 18977 : gcc_checking_assert (ns);
3995 : 18977 : if (STAT_HACK_P (*slot))
3996 : 0 : STAT_DECL (*slot) = head;
3997 : : else
3998 : 18977 : *slot = head;
3999 : : }
4000 : 3747013 : if (DECL_EXTERN_C_P (match))
4001 : : /* We need to check and register the decl now. */
4002 : 3502126 : check_extern_c_conflict (match);
4003 : : }
4004 : 4747703 : else if (slot
4005 : 4747703 : && !hiding
4006 : 4034884 : && STAT_HACK_P (*slot)
4007 : 4747721 : && STAT_DECL_HIDDEN_P (*slot))
4008 : : {
4009 : : /* Unhide the non-function. */
4010 : 18 : gcc_checking_assert (oldi == match);
4011 : 18 : if (!STAT_TYPE (*slot))
4012 : 18 : *slot = match;
4013 : : else
4014 : 0 : STAT_DECL (*slot) = match;
4015 : : }
4016 : 8516899 : return match;
4017 : : }
4018 : : }
4019 : :
4020 : : /* Check for redeclaring an import. */
4021 : 1103274072 : if (slot && *slot && TREE_CODE (*slot) == BINDING_VECTOR)
4022 : 784 : if (tree match
4023 : 392 : = check_module_override (decl, *slot, hiding, ns, name))
4024 : : {
4025 : 266 : if (match == error_mark_node)
4026 : : return match;
4027 : :
4028 : : /* We found a decl in an interface, push it into this
4029 : : binding. */
4030 : 224 : decl = update_binding (NULL, binding, mslot, old,
4031 : : match, hiding);
4032 : :
4033 : 224 : return decl;
4034 : : }
4035 : :
4036 : : /* We are pushing a new decl. */
4037 : :
4038 : : /* Skip a hidden builtin we failed to match already. There can
4039 : : only be one. */
4040 : 1103273806 : if (old && anticipated_builtin_p (old))
4041 : 844395 : old = OVL_CHAIN (old);
4042 : :
4043 : 1103273806 : check_template_shadow (decl);
4044 : :
4045 : 1103273806 : if (DECL_DECLARES_FUNCTION_P (decl))
4046 : : {
4047 : 302243118 : check_default_args (decl);
4048 : :
4049 : 302243118 : if (hiding)
4050 : : {
4051 : 69305275 : if (level->kind != sk_namespace)
4052 : : {
4053 : : /* In a local class, a friend function declaration must
4054 : : find a matching decl in the innermost non-class scope.
4055 : : [class.friend/11] */
4056 : 9 : error_at (DECL_SOURCE_LOCATION (decl),
4057 : : "friend declaration %qD in local class without "
4058 : : "prior local declaration", decl);
4059 : : /* Don't attempt to push it. */
4060 : 9 : return error_mark_node;
4061 : : }
4062 : : }
4063 : : }
4064 : :
4065 : 1103273797 : if (level->kind != sk_namespace)
4066 : : {
4067 : 770808207 : tree local_shadow = check_local_shadow (decl);
4068 : 770808207 : if (name_independent_p && local_shadow)
4069 : : {
4070 : 57 : if (cxx_dialect < cxx26 && !name_independent_diagnosed_p)
4071 : 53 : pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wc__26_extensions,
4072 : : "name-independent declarations only available with "
4073 : : "%<-std=c++2c%> or %<-std=gnu++2c%>");
4074 : 57 : name_independent_diagnosed_p = true;
4075 : : /* When a name-independent declaration is pushed into a scope
4076 : : which itself does not contain a _ named declaration yet (so
4077 : : _ name lookups wouldn't be normally ambiguous), but it
4078 : : shadows a _ declaration in some outer scope in cases
4079 : : described in [basic.scope.block]/2 where if the names of
4080 : : the shadowed and shadowing declarations were different it
4081 : : would be ill-formed program, arrange for _ name lookups
4082 : : in this scope to be ambiguous. */
4083 : 57 : if (old == NULL_TREE)
4084 : : {
4085 : 57 : old = build_tree_list (error_mark_node, local_shadow);
4086 : 57 : TREE_TYPE (old) = error_mark_node;
4087 : : }
4088 : : }
4089 : :
4090 : 770808207 : if (TREE_CODE (decl) == NAMESPACE_DECL)
4091 : : /* A local namespace alias. */
4092 : 101868 : set_identifier_type_value_with_scope (name, NULL_TREE, level);
4093 : :
4094 : 770808207 : if (!binding)
4095 : 770807864 : binding = create_local_binding (level, name);
4096 : : }
4097 : 332465590 : else if (!slot)
4098 : : {
4099 : 33 : ns = current_namespace;
4100 : 33 : slot = find_namespace_slot (ns, name, true);
4101 : 33 : mslot = get_fixed_binding_slot (slot, name, BINDING_SLOT_CURRENT, true);
4102 : : /* Update OLD to reflect the namespace we're going to be
4103 : : pushing into. */
4104 : 33 : old = MAYBE_STAT_DECL (*mslot);
4105 : : }
4106 : :
4107 : 1103273797 : old = update_binding (level, binding, mslot, old, decl, hiding);
4108 : :
4109 : 1103273797 : if (old != decl)
4110 : : /* An existing decl matched, use it. */
4111 : : decl = old;
4112 : : else
4113 : : {
4114 : 1103273776 : if (TREE_CODE (decl) == TYPE_DECL)
4115 : : {
4116 : 207007817 : tree type = TREE_TYPE (decl);
4117 : :
4118 : 207007817 : if (type != error_mark_node)
4119 : : {
4120 : 207007751 : if (TYPE_NAME (type) != decl)
4121 : 19324782 : set_underlying_type (decl);
4122 : :
4123 : 207007751 : set_identifier_type_value_with_scope (name, decl, level);
4124 : :
4125 : 207007751 : if (level->kind != sk_namespace
4126 : 207007751 : && !instantiating_current_function_p ())
4127 : : /* This is a locally defined typedef in a function that
4128 : : is not a template instantation, record it to implement
4129 : : -Wunused-local-typedefs. */
4130 : 193915172 : record_locally_defined_typedef (decl);
4131 : : }
4132 : : }
4133 : 896265959 : else if (VAR_OR_FUNCTION_DECL_P (decl))
4134 : : {
4135 : 350432022 : if (DECL_EXTERN_C_P (decl))
4136 : 260271209 : check_extern_c_conflict (decl);
4137 : :
4138 : 350432022 : if (!DECL_LOCAL_DECL_P (decl)
4139 : 350432022 : && VAR_P (decl))
4140 : 71698577 : maybe_register_incomplete_var (decl);
4141 : :
4142 : 350432022 : if (DECL_LOCAL_DECL_P (decl)
4143 : 350432022 : && NAMESPACE_SCOPE_P (decl))
4144 : 36134 : push_local_extern_decl_alias (decl);
4145 : : }
4146 : :
4147 : 1103273776 : if (level->kind == sk_namespace
4148 : 332465575 : && TREE_PUBLIC (level->this_entity)
4149 : 1435735119 : && module_maybe_has_cmi_p ())
4150 : 271693 : maybe_record_mergeable_decl (slot, name, decl);
4151 : : }
4152 : : }
4153 : : else
4154 : 25272415 : add_decl_to_level (level, decl);
4155 : :
4156 : : return decl;
4157 : 1137063392 : }
4158 : :
4159 : : /* A mergeable entity is being loaded into namespace NS slot NAME.
4160 : : Create and return the appropriate vector slot for that. Either a
4161 : : GMF slot or a module-specific one. */
4162 : :
4163 : : tree *
4164 : 251624 : mergeable_namespace_slots (tree ns, tree name, bool is_attached, tree *vec)
4165 : : {
4166 : 251624 : tree *mslot = find_namespace_slot (ns, name, true);
4167 : 251624 : tree *vslot = get_fixed_binding_slot
4168 : 502728 : (mslot, name, is_attached ? BINDING_SLOT_PARTITION : BINDING_SLOT_GLOBAL,
4169 : : true);
4170 : :
4171 : 251624 : gcc_checking_assert (TREE_CODE (*mslot) == BINDING_VECTOR);
4172 : 251624 : *vec = *mslot;
4173 : :
4174 : 251624 : return vslot;
4175 : : }
4176 : :
4177 : : /* Retrieve the bindings for an existing mergeable entity in namespace
4178 : : NS slot NAME. Returns NULL if no such bindings exists. */
4179 : :
4180 : : static tree
4181 : 27 : get_mergeable_namespace_binding (tree ns, tree name, bool is_attached)
4182 : : {
4183 : 27 : tree *mslot = find_namespace_slot (ns, name, false);
4184 : 27 : if (!mslot || !*mslot || TREE_CODE (*mslot) != BINDING_VECTOR)
4185 : : return NULL_TREE;
4186 : :
4187 : 12 : tree *vslot = get_fixed_binding_slot
4188 : 24 : (mslot, name, is_attached ? BINDING_SLOT_PARTITION : BINDING_SLOT_GLOBAL,
4189 : : false);
4190 : 12 : return vslot ? *vslot : NULL_TREE;
4191 : : }
4192 : :
4193 : : /* DECL is a new mergeable namespace-scope decl. Add it to the
4194 : : mergeable entities on GSLOT. */
4195 : :
4196 : : void
4197 : 88939 : add_mergeable_namespace_entity (tree *gslot, tree decl)
4198 : : {
4199 : 88939 : *gslot = ovl_make (decl, *gslot);
4200 : 88939 : }
4201 : :
4202 : : /* A mergeable entity of KLASS called NAME is being loaded. Return
4203 : : the set of things it could be. All such non-as_base classes have
4204 : : been given a member vec. */
4205 : :
4206 : : tree
4207 : 325905 : lookup_class_binding (tree klass, tree name)
4208 : : {
4209 : 325905 : tree found = NULL_TREE;
4210 : :
4211 : 325905 : if (!COMPLETE_TYPE_P (klass))
4212 : : ;
4213 : 325905 : else if (TYPE_LANG_SPECIFIC (klass))
4214 : : {
4215 : 322763 : vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
4216 : :
4217 : 322763 : found = member_vec_binary_search (member_vec, name);
4218 : 322763 : if (!found)
4219 : : ;
4220 : 322184 : else if (STAT_HACK_P (found))
4221 : : /* Rearrange the stat hack so that we don't need to expose that
4222 : : internal detail. */
4223 : 6 : found = ovl_make (STAT_TYPE (found), STAT_DECL (found));
4224 : 322178 : else if (IDENTIFIER_CONV_OP_P (name))
4225 : : {
4226 : 1356 : gcc_checking_assert (name == conv_op_identifier);
4227 : 1356 : found = OVL_CHAIN (found);
4228 : : }
4229 : : }
4230 : : else
4231 : : {
4232 : 3142 : gcc_checking_assert (IS_FAKE_BASE_TYPE (klass)
4233 : : || TYPE_PTRMEMFUNC_P (klass));
4234 : 3142 : found = fields_linear_search (klass, name, false);
4235 : : }
4236 : :
4237 : 325905 : return found;
4238 : : }
4239 : :
4240 : : /* Whether this using is declared in the module purview. */
4241 : :
4242 : : bool
4243 : 20957 : ovl_iterator::purview_p () const
4244 : : {
4245 : 20957 : gcc_checking_assert (using_p ());
4246 : 20957 : if (TREE_CODE (ovl) == USING_DECL)
4247 : 2759 : return DECL_MODULE_PURVIEW_P (ovl);
4248 : 18198 : return OVL_PURVIEW_P (ovl);
4249 : : }
4250 : :
4251 : : /* Whether this using is exported from this module. */
4252 : :
4253 : : bool
4254 : 20957 : ovl_iterator::exporting_p () const
4255 : : {
4256 : 20957 : gcc_checking_assert (using_p ());
4257 : 20957 : if (TREE_CODE (ovl) == USING_DECL)
4258 : 2759 : return DECL_MODULE_EXPORT_P (ovl);
4259 : 18198 : return OVL_EXPORT_P (ovl);
4260 : : }
4261 : :
4262 : : /* Given a namespace-level binding BINDING, walk it, calling CALLBACK
4263 : : for all decls of the current module. When partitions are involved,
4264 : : decls might be mentioned more than once. Return the accumulation of
4265 : : CALLBACK results. */
4266 : :
4267 : : unsigned
4268 : 5411125 : walk_module_binding (tree binding, bitmap partitions,
4269 : : bool (*callback) (tree decl, WMB_Flags, void *data),
4270 : : void *data)
4271 : : {
4272 : 5411125 : tree current = binding;
4273 : 5411125 : unsigned count = 0;
4274 : :
4275 : 5411125 : if (TREE_CODE (binding) == BINDING_VECTOR)
4276 : 15285 : current = BINDING_VECTOR_CLUSTER (binding, 0).slots[BINDING_SLOT_CURRENT];
4277 : :
4278 : 5412113 : bool decl_hidden = false;
4279 : 5411125 : if (tree type = MAYBE_STAT_TYPE (current))
4280 : : {
4281 : 85 : WMB_Flags flags = WMB_None;
4282 : 85 : if (STAT_TYPE_HIDDEN_P (current))
4283 : 0 : flags = WMB_Flags (flags | WMB_Hidden);
4284 : 85 : if (TREE_CODE (type) == USING_DECL)
4285 : : {
4286 : 3 : flags = WMB_Flags (flags | WMB_Using);
4287 : 3 : if (DECL_MODULE_PURVIEW_P (type))
4288 : 3 : flags = WMB_Flags (flags | WMB_Purview);
4289 : 3 : if (DECL_MODULE_EXPORT_P (type))
4290 : 3 : flags = WMB_Flags (flags | WMB_Export);
4291 : : }
4292 : 85 : count += callback (type, flags, data);
4293 : 85 : decl_hidden = STAT_DECL_HIDDEN_P (current);
4294 : : }
4295 : :
4296 : 10884267 : for (ovl_iterator iter (MAYBE_STAT_DECL (current)); iter; ++iter)
4297 : : {
4298 : 5473142 : if (iter.hidden_p ())
4299 : : decl_hidden = true;
4300 : 5473142 : if (!(decl_hidden && DECL_IS_UNDECLARED_BUILTIN (*iter)))
4301 : : {
4302 : 4138783 : WMB_Flags flags = WMB_None;
4303 : 4138783 : if (decl_hidden)
4304 : 6774 : flags = WMB_Flags (flags | WMB_Hidden);
4305 : 4138783 : if (iter.using_p ())
4306 : : {
4307 : 20948 : flags = WMB_Flags (flags | WMB_Using);
4308 : 20948 : if (iter.purview_p ())
4309 : 16517 : flags = WMB_Flags (flags | WMB_Purview);
4310 : 20948 : if (iter.exporting_p ())
4311 : 16496 : flags = WMB_Flags (flags | WMB_Export);
4312 : : }
4313 : 4138783 : count += callback (*iter, flags, data);
4314 : : }
4315 : 5473142 : decl_hidden = false;
4316 : : }
4317 : :
4318 : 5411125 : if (partitions && TREE_CODE (binding) == BINDING_VECTOR)
4319 : : {
4320 : : /* Process partition slots. */
4321 : 193 : binding_cluster *cluster = BINDING_VECTOR_CLUSTER_BASE (binding);
4322 : 193 : unsigned ix = BINDING_VECTOR_NUM_CLUSTERS (binding);
4323 : 193 : if (BINDING_VECTOR_SLOTS_PER_CLUSTER == BINDING_SLOTS_FIXED)
4324 : : {
4325 : 193 : ix--;
4326 : 193 : cluster++;
4327 : : }
4328 : :
4329 : : /* There could be duplicate module or GMF entries. */
4330 : 193 : bool maybe_dups = (BINDING_VECTOR_PARTITION_DUPS_P (binding)
4331 : 193 : || BINDING_VECTOR_GLOBAL_DUPS_P (binding));
4332 : :
4333 : 416 : for (; ix--; cluster++)
4334 : 669 : for (unsigned jx = 0; jx != BINDING_VECTOR_SLOTS_PER_CLUSTER; jx++)
4335 : 446 : if (!cluster->slots[jx].is_lazy ())
4336 : 443 : if (tree bind = cluster->slots[jx])
4337 : : {
4338 : 262 : if (TREE_CODE (bind) == NAMESPACE_DECL
4339 : 262 : && !DECL_NAMESPACE_ALIAS (bind))
4340 : : {
4341 : 17 : if (unsigned base = cluster->indices[jx].base)
4342 : 17 : if (unsigned span = cluster->indices[jx].span)
4343 : 17 : do
4344 : 17 : if (bitmap_bit_p (partitions, base))
4345 : 17 : goto found;
4346 : 0 : while (++base, --span);
4347 : : /* Not a partition's namespace. */
4348 : 0 : continue;
4349 : 17 : found:
4350 : :
4351 : 17 : WMB_Flags flags = WMB_None;
4352 : 17 : if (maybe_dups)
4353 : 0 : flags = WMB_Flags (flags | WMB_Dups);
4354 : 17 : count += callback (bind, flags, data);
4355 : 0 : }
4356 : 245 : else if (STAT_HACK_P (bind) && MODULE_BINDING_PARTITION_P (bind))
4357 : : {
4358 : 141 : if (tree btype = STAT_TYPE (bind))
4359 : : {
4360 : 0 : WMB_Flags flags = WMB_None;
4361 : 0 : if (maybe_dups)
4362 : 0 : flags = WMB_Flags (flags | WMB_Dups);
4363 : 0 : if (STAT_TYPE_HIDDEN_P (bind))
4364 : 0 : flags = WMB_Flags (flags | WMB_Hidden);
4365 : 0 : if (TREE_CODE (btype) == USING_DECL)
4366 : : {
4367 : 0 : flags = WMB_Flags (flags | WMB_Using);
4368 : 0 : if (DECL_MODULE_PURVIEW_P (btype))
4369 : 0 : flags = WMB_Flags (flags | WMB_Purview);
4370 : 0 : if (DECL_MODULE_EXPORT_P (btype))
4371 : 0 : flags = WMB_Flags (flags | WMB_Export);
4372 : : }
4373 : 0 : count += callback (btype, flags, data);
4374 : : }
4375 : 141 : bool part_hidden = STAT_DECL_HIDDEN_P (bind);
4376 : 141 : for (ovl_iterator iter (MAYBE_STAT_DECL (STAT_DECL (bind)));
4377 : 288 : iter; ++iter)
4378 : : {
4379 : 147 : if (iter.hidden_p ())
4380 : : part_hidden = true;
4381 : 147 : gcc_checking_assert
4382 : : (!(part_hidden && DECL_IS_UNDECLARED_BUILTIN (*iter)));
4383 : :
4384 : 147 : WMB_Flags flags = WMB_None;
4385 : 147 : if (maybe_dups)
4386 : 66 : flags = WMB_Flags (flags | WMB_Dups);
4387 : 147 : if (part_hidden)
4388 : 9 : flags = WMB_Flags (flags | WMB_Hidden);
4389 : 147 : if (iter.using_p ())
4390 : : {
4391 : 9 : flags = WMB_Flags (flags | WMB_Using);
4392 : 9 : if (iter.purview_p ())
4393 : 9 : flags = WMB_Flags (flags | WMB_Purview);
4394 : 9 : if (iter.exporting_p ())
4395 : 9 : flags = WMB_Flags (flags | WMB_Export);
4396 : : }
4397 : 147 : count += callback (*iter, flags, data);
4398 : 147 : part_hidden = false;
4399 : : }
4400 : : }
4401 : : }
4402 : : }
4403 : :
4404 : 5411125 : return count;
4405 : : }
4406 : :
4407 : : /* Imported module MOD has a binding to NS::NAME, stored in section
4408 : : SNUM. */
4409 : :
4410 : : bool
4411 : 268267 : import_module_binding (tree ns, tree name, unsigned mod, unsigned snum)
4412 : : {
4413 : 268267 : tree *slot = find_namespace_slot (ns, name, true);
4414 : 268267 : binding_slot *mslot = append_imported_binding_slot (slot, name, mod);
4415 : :
4416 : 268267 : if (mslot->is_lazy () || *mslot)
4417 : : /* Oops, something was already there. */
4418 : : return false;
4419 : :
4420 : 268267 : mslot->set_lazy (snum);
4421 : 268267 : return true;
4422 : : }
4423 : :
4424 : : /* An import of MODULE is binding NS::NAME. There should be no
4425 : : existing binding for >= MODULE. GLOBAL_P indicates whether the
4426 : : bindings include global module entities. PARTITION_P is true if
4427 : : it is part of the current module. VALUE and TYPE are the value
4428 : : and type bindings. VISIBLE are the value bindings being exported. */
4429 : :
4430 : : bool
4431 : 207097 : set_module_binding (tree ns, tree name, unsigned mod, bool global_p,
4432 : : bool partition_p, tree value, tree type, tree visible)
4433 : : {
4434 : 207097 : if (!value)
4435 : : /* Bogus BMIs could give rise to nothing to bind. */
4436 : : return false;
4437 : :
4438 : 207097 : gcc_assert (TREE_CODE (value) != NAMESPACE_DECL
4439 : : || DECL_NAMESPACE_ALIAS (value));
4440 : 207097 : gcc_checking_assert (mod);
4441 : :
4442 : 207097 : tree *slot = find_namespace_slot (ns, name, true);
4443 : 207097 : binding_slot *mslot = search_imported_binding_slot (slot, mod);
4444 : :
4445 : 207097 : if (!mslot || !mslot->is_lazy ())
4446 : : /* Again, bogus BMI could give find to missing or already loaded slot. */
4447 : : return false;
4448 : :
4449 : 207097 : tree bind = value;
4450 : 207097 : if (type || visible != bind || partition_p || global_p)
4451 : : {
4452 : 205849 : bind = stat_hack (bind, type);
4453 : 205849 : STAT_VISIBLE (bind) = visible;
4454 : 538 : if ((partition_p && TREE_PUBLIC (ns))
4455 : 205849 : || (type && DECL_MODULE_EXPORT_P (type)))
4456 : 573 : STAT_TYPE_VISIBLE_P (bind) = true;
4457 : : }
4458 : :
4459 : : /* Note if this is this-module and/or global binding. */
4460 : 205849 : if (partition_p)
4461 : 538 : MODULE_BINDING_PARTITION_P (bind) = true;
4462 : 207097 : if (global_p)
4463 : 205202 : MODULE_BINDING_GLOBAL_P (bind) = true;
4464 : :
4465 : 207097 : *mslot = bind;
4466 : :
4467 : 207097 : return true;
4468 : : }
4469 : :
4470 : : void
4471 : 90386 : add_module_namespace_decl (tree ns, tree decl)
4472 : : {
4473 : 90386 : gcc_assert (!DECL_CHAIN (decl));
4474 : 90386 : gcc_checking_assert (!(VAR_OR_FUNCTION_DECL_P (decl)
4475 : : && DECL_LOCAL_DECL_P (decl)));
4476 : 90386 : if (CHECKING_P)
4477 : : /* Expensive already-there? check. */
4478 : 160473040 : for (auto probe = NAMESPACE_LEVEL (ns)->names; probe;
4479 : 160382654 : probe = DECL_CHAIN (probe))
4480 : 160382654 : gcc_assert (decl != probe);
4481 : :
4482 : 90386 : add_decl_to_level (NAMESPACE_LEVEL (ns), decl);
4483 : :
4484 : 90386 : if (VAR_P (decl))
4485 : 1888 : maybe_register_incomplete_var (decl);
4486 : :
4487 : 88498 : if (VAR_OR_FUNCTION_DECL_P (decl)
4488 : 125945 : && DECL_EXTERN_C_P (decl))
4489 : 23291 : check_extern_c_conflict (decl);
4490 : 90386 : }
4491 : :
4492 : : /* Enter DECL into the symbol table, if that's appropriate. Returns
4493 : : DECL, or a modified version thereof. */
4494 : :
4495 : : tree
4496 : 125068590 : maybe_push_decl (tree decl)
4497 : : {
4498 : 125068590 : tree type = TREE_TYPE (decl);
4499 : :
4500 : : /* Add this decl to the current binding level, but not if it comes
4501 : : from another scope, e.g. a static member variable. TEM may equal
4502 : : DECL or it may be a previous decl of the same name. */
4503 : 125068590 : if (decl == error_mark_node
4504 : 125068585 : || (TREE_CODE (decl) != PARM_DECL
4505 : 125068585 : && DECL_CONTEXT (decl) != NULL_TREE
4506 : : /* Definitions of namespace members outside their namespace are
4507 : : possible. */
4508 : 46632921 : && !DECL_NAMESPACE_SCOPE_P (decl))
4509 : 123792913 : || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4510 : 123792913 : || type == unknown_type_node
4511 : : /* The declaration of a template specialization does not affect
4512 : : the functions available for overload resolution, so we do not
4513 : : call pushdecl. */
4514 : 248861503 : || (TREE_CODE (decl) == FUNCTION_DECL
4515 : 35585855 : && DECL_TEMPLATE_SPECIALIZATION (decl)))
4516 : 1367181 : return decl;
4517 : : else
4518 : 123701409 : return pushdecl (decl);
4519 : : }
4520 : :
4521 : : /* Bind DECL to ID in the current_binding_level, assumed to be a local
4522 : : binding level. If IS_USING is true, DECL got here through a
4523 : : using-declaration. */
4524 : :
4525 : : static void
4526 : 670040 : push_local_binding (tree id, tree decl, bool is_using)
4527 : : {
4528 : : /* Skip over any local classes. This makes sense if we call
4529 : : push_local_binding with a friend decl of a local class. */
4530 : 670040 : cp_binding_level *b = innermost_nonclass_level ();
4531 : :
4532 : 670040 : gcc_assert (b->kind != sk_namespace);
4533 : 670040 : if (find_local_binding (b, id))
4534 : : {
4535 : : /* Supplement the existing binding. */
4536 : 18 : if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
4537 : : /* It didn't work. Something else must be bound at this
4538 : : level. Do not add DECL to the list of things to pop
4539 : : later. */
4540 : : return;
4541 : : }
4542 : : else
4543 : : /* Create a new binding. */
4544 : 670022 : push_binding (id, decl, b);
4545 : :
4546 : 670040 : if (TREE_CODE (decl) == OVERLOAD || is_using)
4547 : : /* We must put the OVERLOAD or using into a TREE_LIST since we
4548 : : cannot use the decl's chain itself. */
4549 : 670040 : decl = build_tree_list (id, decl);
4550 : :
4551 : : /* And put DECL on the list of things declared by the current
4552 : : binding level. */
4553 : 670040 : add_decl_to_level (b, decl);
4554 : : }
4555 : :
4556 : : /* Lookup the FRIEND_TMPL within all merged module imports. Used to dedup
4557 : : instantiations of temploid hidden friends from imported modules. */
4558 : :
4559 : : tree
4560 : 268 : lookup_imported_hidden_friend (tree friend_tmpl)
4561 : : {
4562 : : /* For a class-scope friend class it should have been found by regular
4563 : : name lookup. Otherwise we're looking in the current namespace. */
4564 : 268 : gcc_checking_assert (CP_DECL_CONTEXT (friend_tmpl) == current_namespace);
4565 : :
4566 : 268 : tree inner = DECL_TEMPLATE_RESULT (friend_tmpl);
4567 : 268 : if (!DECL_LANG_SPECIFIC (inner)
4568 : 306 : || !DECL_MODULE_IMPORT_P (inner))
4569 : : return NULL_TREE;
4570 : :
4571 : 27 : tree bind = get_mergeable_namespace_binding
4572 : 27 : (current_namespace, DECL_NAME (inner), DECL_MODULE_ATTACH_P (inner));
4573 : 27 : if (!bind)
4574 : : return NULL_TREE;
4575 : :
4576 : : /* We're only interested in declarations coming from the same module
4577 : : of the friend class we're attempting to instantiate. */
4578 : 12 : int m = get_originating_module (friend_tmpl);
4579 : 12 : gcc_assert (m != 0);
4580 : :
4581 : : /* There should be at most one class template from the module we're
4582 : : looking for, return it. */
4583 : 12 : for (ovl_iterator iter (bind); iter; ++iter)
4584 : 24 : if (DECL_CLASS_TEMPLATE_P (*iter)
4585 : 24 : && get_originating_module (*iter) == m)
4586 : 12 : return *iter;
4587 : :
4588 : 0 : return NULL_TREE;
4589 : : }
4590 : :
4591 : :
4592 : : /* true means unconditionally make a BLOCK for the next level pushed. */
4593 : :
4594 : : static bool keep_next_level_flag;
4595 : :
4596 : : static int binding_depth = 0;
4597 : :
4598 : : static void
4599 : 0 : indent (int depth)
4600 : : {
4601 : 0 : int i;
4602 : :
4603 : 0 : for (i = 0; i < depth * 2; i++)
4604 : 0 : putc (' ', stderr);
4605 : 0 : }
4606 : :
4607 : : /* Return a string describing the kind of SCOPE we have. */
4608 : : static const char *
4609 : 0 : cp_binding_level_descriptor (cp_binding_level *scope)
4610 : : {
4611 : : /* The order of this table must match the "scope_kind"
4612 : : enumerators. */
4613 : 0 : static const char* scope_kind_names[] = {
4614 : : "block-scope",
4615 : : "cleanup-scope",
4616 : : "try-scope",
4617 : : "catch-scope",
4618 : : "for-scope",
4619 : : "cond-init-scope",
4620 : : "stmt-expr-scope",
4621 : : "function-parameter-scope",
4622 : : "class-scope",
4623 : : "enum-scope",
4624 : : "namespace-scope",
4625 : : "template-parameter-scope",
4626 : : "template-explicit-spec-scope",
4627 : : "transaction-scope",
4628 : : "openmp-scope"
4629 : : };
4630 : 0 : static_assert (ARRAY_SIZE (scope_kind_names) == sk_count,
4631 : : "must keep names aligned with scope_kind enum");
4632 : :
4633 : 0 : scope_kind kind = scope->kind;
4634 : 0 : if (kind == sk_template_parms && scope->explicit_spec_p)
4635 : 0 : kind = sk_template_spec;
4636 : :
4637 : 0 : return scope_kind_names[kind];
4638 : : }
4639 : :
4640 : : /* Output a debugging information about SCOPE when performing
4641 : : ACTION at LINE. */
4642 : : static void
4643 : 0 : cp_binding_level_debug (cp_binding_level *scope, int line, const char *action)
4644 : : {
4645 : 0 : const char *desc = cp_binding_level_descriptor (scope);
4646 : 0 : if (scope->this_entity)
4647 : 0 : verbatim ("%s %<%s(%E)%> %p %d", action, desc,
4648 : : scope->this_entity, (void *) scope, line);
4649 : : else
4650 : 0 : verbatim ("%s %s %p %d", action, desc, (void *) scope, line);
4651 : 0 : }
4652 : :
4653 : : /* A chain of binding_level structures awaiting reuse. */
4654 : :
4655 : : static GTY((deletable)) cp_binding_level *free_binding_level;
4656 : :
4657 : : /* Insert SCOPE as the innermost binding level. */
4658 : :
4659 : : void
4660 : 1059770856 : push_binding_level (cp_binding_level *scope)
4661 : : {
4662 : : /* Add it to the front of currently active scopes stack. */
4663 : 1059770856 : scope->level_chain = current_binding_level;
4664 : 1059770856 : current_binding_level = scope;
4665 : 1059770856 : keep_next_level_flag = false;
4666 : :
4667 : 1059770856 : if (ENABLE_SCOPE_CHECKING)
4668 : : {
4669 : : scope->binding_depth = binding_depth;
4670 : : indent (binding_depth);
4671 : : cp_binding_level_debug (scope, LOCATION_LINE (input_location),
4672 : : "push");
4673 : : binding_depth++;
4674 : : }
4675 : 1059770856 : }
4676 : :
4677 : : /* Create a new KIND scope and make it the top of the active scopes stack.
4678 : : ENTITY is the scope of the associated C++ entity (namespace, class,
4679 : : function, C++0x enumeration); it is NULL otherwise. */
4680 : :
4681 : : cp_binding_level *
4682 : 890961535 : begin_scope (scope_kind kind, tree entity)
4683 : : {
4684 : 890961535 : cp_binding_level *scope;
4685 : :
4686 : : /* Reuse or create a struct for this binding level. */
4687 : 890961535 : if (!ENABLE_SCOPE_CHECKING && free_binding_level)
4688 : : {
4689 : 863283714 : scope = free_binding_level;
4690 : 863283714 : free_binding_level = scope->level_chain;
4691 : 863283714 : memset (scope, 0, sizeof (cp_binding_level));
4692 : : }
4693 : : else
4694 : 27677821 : scope = ggc_cleared_alloc<cp_binding_level> ();
4695 : :
4696 : 890961535 : scope->this_entity = entity;
4697 : 890961535 : scope->more_cleanups_ok = true;
4698 : 890961535 : switch (kind)
4699 : : {
4700 : 450 : case sk_cleanup:
4701 : 450 : scope->keep = true;
4702 : 450 : break;
4703 : :
4704 : 4938656 : case sk_template_spec:
4705 : 4938656 : scope->explicit_spec_p = true;
4706 : 4938656 : kind = sk_template_parms;
4707 : : /* Fall through. */
4708 : 577190673 : case sk_template_parms:
4709 : 577190673 : case sk_block:
4710 : 577190673 : case sk_try:
4711 : 577190673 : case sk_catch:
4712 : 577190673 : case sk_for:
4713 : 577190673 : case sk_cond:
4714 : 577190673 : case sk_class:
4715 : 577190673 : case sk_scoped_enum:
4716 : 577190673 : case sk_transaction:
4717 : 577190673 : case sk_omp:
4718 : 577190673 : case sk_stmt_expr:
4719 : 577190673 : scope->keep = keep_next_level_flag;
4720 : 577190673 : break;
4721 : :
4722 : 313678343 : case sk_function_parms:
4723 : 313678343 : scope->keep = keep_next_level_flag;
4724 : 313678343 : break;
4725 : :
4726 : 92069 : case sk_namespace:
4727 : 92069 : NAMESPACE_LEVEL (entity) = scope;
4728 : 92069 : break;
4729 : :
4730 : 0 : default:
4731 : : /* Should not happen. */
4732 : 0 : gcc_unreachable ();
4733 : 890961535 : break;
4734 : : }
4735 : 890961535 : scope->kind = kind;
4736 : :
4737 : 890961535 : push_binding_level (scope);
4738 : :
4739 : 890961535 : return scope;
4740 : : }
4741 : :
4742 : : /* We're about to leave current scope. Pop the top of the stack of
4743 : : currently active scopes. Return the enclosing scope, now active. */
4744 : :
4745 : : cp_binding_level *
4746 : 1102557303 : leave_scope (void)
4747 : : {
4748 : 1102557303 : cp_binding_level *scope = current_binding_level;
4749 : :
4750 : 1102557303 : if (scope->kind == sk_namespace && class_binding_level)
4751 : 0 : current_binding_level = class_binding_level;
4752 : :
4753 : : /* We cannot leave a scope, if there are none left. */
4754 : 1102557303 : if (NAMESPACE_LEVEL (global_namespace))
4755 : 1102557303 : gcc_assert (!global_scope_p (scope));
4756 : :
4757 : 1102557303 : if (ENABLE_SCOPE_CHECKING)
4758 : : {
4759 : : indent (--binding_depth);
4760 : : cp_binding_level_debug (scope, LOCATION_LINE (input_location),
4761 : : "leave");
4762 : : }
4763 : :
4764 : : /* Move one nesting level up. */
4765 : 1102557303 : current_binding_level = scope->level_chain;
4766 : :
4767 : : /* Namespace-scopes are left most probably temporarily, not
4768 : : completely; they can be reopened later, e.g. in namespace-extension
4769 : : or any name binding activity that requires us to resume a
4770 : : namespace. For classes, we cache some binding levels. For other
4771 : : scopes, we just make the structure available for reuse. */
4772 : 1102557303 : if (scope->kind != sk_namespace
4773 : 1059662440 : && scope != previous_class_level)
4774 : : {
4775 : 840270019 : scope->level_chain = free_binding_level;
4776 : 840270019 : gcc_assert (!ENABLE_SCOPE_CHECKING
4777 : : || scope->binding_depth == binding_depth);
4778 : 840270019 : free_binding_level = scope;
4779 : : }
4780 : :
4781 : 1102557303 : if (scope->kind == sk_class)
4782 : : {
4783 : : /* Reset DEFINING_CLASS_P to allow for reuse of a
4784 : : class-defining scope in a non-defining context. */
4785 : 341628301 : scope->defining_class_p = 0;
4786 : :
4787 : : /* Find the innermost enclosing class scope, and reset
4788 : : CLASS_BINDING_LEVEL appropriately. */
4789 : 341628301 : class_binding_level = NULL;
4790 : 1078157327 : for (scope = current_binding_level; scope; scope = scope->level_chain)
4791 : 781359537 : if (scope->kind == sk_class)
4792 : : {
4793 : 44830511 : class_binding_level = scope;
4794 : 44830511 : break;
4795 : : }
4796 : : }
4797 : :
4798 : 1102557303 : return current_binding_level;
4799 : : }
4800 : :
4801 : : /* When we exit a toplevel class scope, we save its binding level so
4802 : : that we can restore it quickly. Here, we've entered some other
4803 : : class, so we must invalidate our cache. */
4804 : :
4805 : : void
4806 : 24181718 : invalidate_class_lookup_cache (void)
4807 : : {
4808 : 24181718 : previous_class_level->level_chain = free_binding_level;
4809 : 24181718 : free_binding_level = previous_class_level;
4810 : 24181718 : previous_class_level = NULL;
4811 : 24181718 : }
4812 : :
4813 : : static void
4814 : 42894872 : resume_scope (cp_binding_level* b)
4815 : : {
4816 : : /* Resuming binding levels is meant only for namespaces,
4817 : : and those cannot nest into classes. */
4818 : 42894872 : gcc_assert (!class_binding_level);
4819 : : /* Also, resuming a non-directly nested namespace is a no-no. */
4820 : 42894872 : gcc_assert (b->level_chain == current_binding_level);
4821 : 42894872 : current_binding_level = b;
4822 : 42894872 : if (ENABLE_SCOPE_CHECKING)
4823 : : {
4824 : : b->binding_depth = binding_depth;
4825 : : indent (binding_depth);
4826 : : cp_binding_level_debug (b, LOCATION_LINE (input_location), "resume");
4827 : : binding_depth++;
4828 : : }
4829 : 42894872 : }
4830 : :
4831 : : /* Return the innermost binding level that is not for a class scope. */
4832 : :
4833 : : static cp_binding_level *
4834 : 1397673161 : innermost_nonclass_level (void)
4835 : : {
4836 : 1397673161 : cp_binding_level *b;
4837 : :
4838 : 1397673161 : b = current_binding_level;
4839 : 1606070948 : while (b->kind == sk_class)
4840 : 208397787 : b = b->level_chain;
4841 : :
4842 : 1397673161 : return b;
4843 : : }
4844 : :
4845 : : /* We're defining an object of type TYPE. If it needs a cleanup, but
4846 : : we're not allowed to add any more objects with cleanups to the current
4847 : : scope, create a new binding level. */
4848 : :
4849 : : void
4850 : 5080615 : maybe_push_cleanup_level (tree type)
4851 : : {
4852 : 5080615 : if (type != error_mark_node
4853 : 5080431 : && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
4854 : 5401925 : && current_binding_level->more_cleanups_ok == 0)
4855 : : {
4856 : 450 : begin_scope (sk_cleanup, NULL);
4857 : 450 : current_binding_level->statement_list = push_stmt_list ();
4858 : : }
4859 : 5080615 : }
4860 : :
4861 : : /* Return true if we are in the global binding level. */
4862 : :
4863 : : bool
4864 : 315930 : global_bindings_p (void)
4865 : : {
4866 : 315930 : return global_scope_p (current_binding_level);
4867 : : }
4868 : :
4869 : : /* True if we are currently in a toplevel binding level. This
4870 : : means either the global binding level or a namespace in a toplevel
4871 : : binding level. Since there are no non-toplevel namespace levels,
4872 : : this really means any namespace or template parameter level. We
4873 : : also include a class whose context is toplevel. */
4874 : :
4875 : : bool
4876 : 1373639828 : toplevel_bindings_p (void)
4877 : : {
4878 : 1373639828 : cp_binding_level *b = innermost_nonclass_level ();
4879 : :
4880 : 1373639828 : return b->kind == sk_namespace || b->kind == sk_template_parms;
4881 : : }
4882 : :
4883 : : /* True if this is a namespace scope, or if we are defining a class
4884 : : which is itself at namespace scope, or whose enclosing class is
4885 : : such a class, etc. */
4886 : :
4887 : : bool
4888 : 23361589 : namespace_bindings_p (void)
4889 : : {
4890 : 23361589 : cp_binding_level *b = innermost_nonclass_level ();
4891 : :
4892 : 23361589 : return b->kind == sk_namespace;
4893 : : }
4894 : :
4895 : : /* True if the innermost non-class scope is a block scope. */
4896 : :
4897 : : bool
4898 : 1704 : local_bindings_p (void)
4899 : : {
4900 : 1704 : cp_binding_level *b = innermost_nonclass_level ();
4901 : 1704 : return b->kind < sk_function_parms || b->kind == sk_omp;
4902 : : }
4903 : :
4904 : : /* True if the current level needs to have a BLOCK made. */
4905 : :
4906 : : bool
4907 : 287681894 : kept_level_p (void)
4908 : : {
4909 : 287681894 : return (current_binding_level->blocks != NULL_TREE
4910 : 258506469 : || current_binding_level->keep
4911 : 252018434 : || current_binding_level->kind == sk_cleanup
4912 : 252018434 : || current_binding_level->names != NULL_TREE
4913 : 511132307 : || current_binding_level->using_directives);
4914 : : }
4915 : :
4916 : : /* Returns the kind of the innermost scope. */
4917 : :
4918 : : scope_kind
4919 : 2374792068 : innermost_scope_kind (void)
4920 : : {
4921 : 2374792068 : return current_binding_level->kind;
4922 : : }
4923 : :
4924 : : /* Returns true if this scope was created to store template parameters. */
4925 : :
4926 : : bool
4927 : 538318128 : template_parm_scope_p (void)
4928 : : {
4929 : 538318128 : return innermost_scope_kind () == sk_template_parms;
4930 : : }
4931 : :
4932 : : /* If KEEP is true, make a BLOCK node for the next binding level,
4933 : : unconditionally. Otherwise, use the normal logic to decide whether
4934 : : or not to create a BLOCK. */
4935 : :
4936 : : void
4937 : 10337696 : keep_next_level (bool keep)
4938 : : {
4939 : 10337696 : keep_next_level_flag = keep;
4940 : 10337696 : }
4941 : :
4942 : : /* Return the list of declarations of the current local scope. */
4943 : :
4944 : : tree
4945 : 313606314 : get_local_decls (void)
4946 : : {
4947 : 313606314 : gcc_assert (current_binding_level->kind != sk_namespace
4948 : : && current_binding_level->kind != sk_class);
4949 : 313606314 : return current_binding_level->names;
4950 : : }
4951 : :
4952 : : /* Return how many function prototypes we are currently nested inside. */
4953 : :
4954 : : int
4955 : 252978011 : function_parm_depth (void)
4956 : : {
4957 : 252978011 : int level = 0;
4958 : 252978011 : cp_binding_level *b;
4959 : :
4960 : 252978011 : for (b = current_binding_level;
4961 : 506681307 : b->kind == sk_function_parms;
4962 : 253703296 : b = b->level_chain)
4963 : 253703296 : ++level;
4964 : :
4965 : 252978011 : return level;
4966 : : }
4967 : :
4968 : : /* For debugging. */
4969 : : static int no_print_functions = 0;
4970 : : static int no_print_builtins = 0;
4971 : :
4972 : : static void
4973 : 0 : print_binding_level (cp_binding_level* lvl)
4974 : : {
4975 : 0 : tree t;
4976 : 0 : int i = 0, len;
4977 : 0 : if (lvl->this_entity)
4978 : 0 : print_node_brief (stderr, "entity=", lvl->this_entity, 1);
4979 : 0 : fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
4980 : 0 : if (lvl->more_cleanups_ok)
4981 : 0 : fprintf (stderr, " more-cleanups-ok");
4982 : 0 : if (lvl->have_cleanups)
4983 : 0 : fprintf (stderr, " have-cleanups");
4984 : 0 : fprintf (stderr, "\n");
4985 : 0 : if (lvl->names)
4986 : : {
4987 : 0 : fprintf (stderr, " names:\t");
4988 : : /* We can probably fit 3 names to a line? */
4989 : 0 : for (t = lvl->names; t; t = TREE_CHAIN (t))
4990 : : {
4991 : 0 : if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
4992 : 0 : continue;
4993 : 0 : if (no_print_builtins
4994 : 0 : && (TREE_CODE (t) == TYPE_DECL)
4995 : 0 : && DECL_IS_UNDECLARED_BUILTIN (t))
4996 : 0 : continue;
4997 : :
4998 : : /* Function decls tend to have longer names. */
4999 : 0 : if (TREE_CODE (t) == FUNCTION_DECL)
5000 : : len = 3;
5001 : : else
5002 : 0 : len = 2;
5003 : 0 : i += len;
5004 : 0 : if (i > 6)
5005 : : {
5006 : 0 : fprintf (stderr, "\n\t");
5007 : 0 : i = len;
5008 : : }
5009 : 0 : print_node_brief (stderr, "", t, 0);
5010 : 0 : if (t == error_mark_node)
5011 : : break;
5012 : : }
5013 : 0 : if (i)
5014 : 0 : fprintf (stderr, "\n");
5015 : : }
5016 : 0 : if (vec_safe_length (lvl->class_shadowed))
5017 : : {
5018 : 0 : size_t i;
5019 : 0 : cp_class_binding *b;
5020 : 0 : fprintf (stderr, " class-shadowed:");
5021 : 0 : FOR_EACH_VEC_ELT (*lvl->class_shadowed, i, b)
5022 : 0 : fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
5023 : 0 : fprintf (stderr, "\n");
5024 : : }
5025 : 0 : if (lvl->type_shadowed)
5026 : : {
5027 : 0 : fprintf (stderr, " type-shadowed:");
5028 : 0 : for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
5029 : : {
5030 : 0 : fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
5031 : : }
5032 : 0 : fprintf (stderr, "\n");
5033 : : }
5034 : 0 : }
5035 : :
5036 : : DEBUG_FUNCTION void
5037 : 0 : debug (cp_binding_level &ref)
5038 : : {
5039 : 0 : print_binding_level (&ref);
5040 : 0 : }
5041 : :
5042 : : DEBUG_FUNCTION void
5043 : 0 : debug (cp_binding_level *ptr)
5044 : : {
5045 : 0 : if (ptr)
5046 : 0 : debug (*ptr);
5047 : : else
5048 : 0 : fprintf (stderr, "<nil>\n");
5049 : 0 : }
5050 : :
5051 : : static void
5052 : 0 : print_other_binding_stack (cp_binding_level *stack)
5053 : : {
5054 : 0 : cp_binding_level *level;
5055 : 0 : for (level = stack; !global_scope_p (level); level = level->level_chain)
5056 : : {
5057 : 0 : fprintf (stderr, "binding level %p\n", (void *) level);
5058 : 0 : print_binding_level (level);
5059 : : }
5060 : 0 : }
5061 : :
5062 : : DEBUG_FUNCTION void
5063 : 0 : print_binding_stack (void)
5064 : : {
5065 : 0 : cp_binding_level *b;
5066 : 0 : fprintf (stderr, "current_binding_level=%p\n"
5067 : : "class_binding_level=%p\n"
5068 : : "NAMESPACE_LEVEL (global_namespace)=%p\n",
5069 : 0 : (void *) current_binding_level, (void *) class_binding_level,
5070 : 0 : (void *) NAMESPACE_LEVEL (global_namespace));
5071 : 0 : if (class_binding_level)
5072 : : {
5073 : 0 : for (b = class_binding_level; b; b = b->level_chain)
5074 : 0 : if (b == current_binding_level)
5075 : : break;
5076 : 0 : if (b)
5077 : : b = class_binding_level;
5078 : : else
5079 : 0 : b = current_binding_level;
5080 : : }
5081 : : else
5082 : 0 : b = current_binding_level;
5083 : 0 : print_other_binding_stack (b);
5084 : 0 : fprintf (stderr, "global:\n");
5085 : 0 : print_binding_level (NAMESPACE_LEVEL (global_namespace));
5086 : 0 : }
5087 : :
5088 : : /* Push a definition of struct, union or enum tag named ID. into
5089 : : binding_level B. DECL is a TYPE_DECL for the type. DECL has
5090 : : already been pushed into its binding level. This is bookkeeping to
5091 : : find it easily. */
5092 : :
5093 : : static void
5094 : 328887321 : set_identifier_type_value_with_scope (tree id, tree decl, cp_binding_level *b)
5095 : : {
5096 : 328887321 : if (b->kind == sk_namespace)
5097 : : /* At namespace scope we should not see an identifier type value. */
5098 : 22091806 : gcc_checking_assert (!REAL_IDENTIFIER_TYPE_VALUE (id)
5099 : : /* We could be pushing a friend underneath a template
5100 : : parm (ill-formed). */
5101 : : || (TEMPLATE_PARM_P
5102 : : (TYPE_NAME (REAL_IDENTIFIER_TYPE_VALUE (id)))));
5103 : : else
5104 : : {
5105 : : /* Push the current type value, so we can restore it later */
5106 : 306795515 : tree old = REAL_IDENTIFIER_TYPE_VALUE (id);
5107 : 306795515 : b->type_shadowed = tree_cons (id, old, b->type_shadowed);
5108 : 306795515 : tree type = decl ? TREE_TYPE (decl) : NULL_TREE;
5109 : 306795515 : TREE_TYPE (b->type_shadowed) = type;
5110 : 306795515 : SET_IDENTIFIER_TYPE_VALUE (id, type);
5111 : : }
5112 : 328887321 : }
5113 : :
5114 : : /* As set_identifier_type_value_with_scope, but using
5115 : : current_binding_level. */
5116 : :
5117 : : void
5118 : 113135684 : set_identifier_type_value (tree id, tree decl)
5119 : : {
5120 : 113135684 : set_identifier_type_value_with_scope (id, decl, current_binding_level);
5121 : 113135684 : }
5122 : :
5123 : : /* Return the name for the constructor (or destructor) for the
5124 : : specified class. */
5125 : :
5126 : : tree
5127 : 321327707 : constructor_name (tree type)
5128 : : {
5129 : 321327707 : tree decl = TYPE_NAME (TYPE_MAIN_VARIANT (type));
5130 : :
5131 : 321327707 : return decl ? DECL_NAME (decl) : NULL_TREE;
5132 : : }
5133 : :
5134 : : /* Returns TRUE if NAME is the name for the constructor for TYPE,
5135 : : which must be a class type. */
5136 : :
5137 : : bool
5138 : 300754620 : constructor_name_p (tree name, tree type)
5139 : : {
5140 : 300754620 : gcc_assert (MAYBE_CLASS_TYPE_P (type));
5141 : :
5142 : : /* These don't have names. */
5143 : 300754620 : if (TREE_CODE (type) == DECLTYPE_TYPE
5144 : 300754617 : || TREE_CODE (type) == TYPEOF_TYPE)
5145 : : return false;
5146 : :
5147 : 300754617 : if (name && name == constructor_name (type))
5148 : : return true;
5149 : :
5150 : : return false;
5151 : : }
5152 : :
5153 : : /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
5154 : : caller to set DECL_CONTEXT properly.
5155 : :
5156 : : Warning: For class and block-scope this must only be used when X
5157 : : will be the new innermost binding for its name, as we tack it onto
5158 : : the front of IDENTIFIER_BINDING without checking to see if the
5159 : : current IDENTIFIER_BINDING comes from a closer binding level than
5160 : : LEVEL.
5161 : :
5162 : : Warning: For namespace scope, this will look in LEVEL for an
5163 : : existing binding to match, but if not found will push the decl into
5164 : : CURRENT_NAMESPACE. Use push_nested_namespace/pushdecl/
5165 : : pop_nested_namespace if you really need to push it into a foreign
5166 : : namespace. */
5167 : :
5168 : : static tree
5169 : 51883639 : do_pushdecl_with_scope (tree x, cp_binding_level *level, bool hiding = false)
5170 : : {
5171 : 51883639 : cp_binding_level *b;
5172 : :
5173 : 51883639 : if (level->kind == sk_class)
5174 : : {
5175 : 0 : gcc_checking_assert (!hiding);
5176 : 0 : b = class_binding_level;
5177 : 0 : class_binding_level = level;
5178 : 0 : pushdecl_class_level (x);
5179 : 0 : class_binding_level = b;
5180 : : }
5181 : : else
5182 : : {
5183 : 51883639 : tree function_decl = current_function_decl;
5184 : 51883639 : if (level->kind == sk_namespace)
5185 : 49040866 : current_function_decl = NULL_TREE;
5186 : 51883639 : b = current_binding_level;
5187 : 51883639 : current_binding_level = level;
5188 : 51883639 : x = pushdecl (x, hiding);
5189 : 51883639 : current_binding_level = b;
5190 : 51883639 : current_function_decl = function_decl;
5191 : : }
5192 : 51883639 : return x;
5193 : : }
5194 : :
5195 : : /* Inject X into the local scope just before the function parms. */
5196 : :
5197 : : tree
5198 : 1404237 : pushdecl_outermost_localscope (tree x)
5199 : : {
5200 : 1404237 : cp_binding_level *b = NULL;
5201 : 1404237 : auto_cond_timevar tv (TV_NAME_LOOKUP);
5202 : :
5203 : : /* Find the scope just inside the function parms. */
5204 : 1404237 : for (cp_binding_level *n = current_binding_level;
5205 : 3642795 : n->kind != sk_function_parms; n = b->level_chain)
5206 : 2238558 : b = n;
5207 : :
5208 : 1404237 : return b ? do_pushdecl_with_scope (x, b) : error_mark_node;
5209 : 1404237 : }
5210 : :
5211 : : /* Checks if BINDING is a binding that we can export. */
5212 : :
5213 : : static bool
5214 : 17300 : check_can_export_using_decl (tree binding)
5215 : : {
5216 : 17300 : tree decl = STRIP_TEMPLATE (binding);
5217 : :
5218 : : /* Linkage is determined by the owner of an enumerator. */
5219 : 17300 : if (TREE_CODE (decl) == CONST_DECL)
5220 : 85 : decl = TYPE_NAME (DECL_CONTEXT (decl));
5221 : :
5222 : : /* If the using decl is exported, the things it refers
5223 : : to must also be exported (or not have module attachment). */
5224 : 17300 : if (!DECL_MODULE_EXPORT_P (decl)
5225 : 17300 : && (DECL_LANG_SPECIFIC (decl)
5226 : 168 : && DECL_MODULE_ATTACH_P (decl)))
5227 : : {
5228 : 103 : bool internal_p = !TREE_PUBLIC (decl);
5229 : :
5230 : : /* A template in an anonymous namespace doesn't constrain TREE_PUBLIC
5231 : : until it's instantiated, so double-check its context. */
5232 : 103 : if (!internal_p && TREE_CODE (binding) == TEMPLATE_DECL)
5233 : 33 : internal_p = decl_internal_context_p (decl);
5234 : :
5235 : 103 : auto_diagnostic_group d;
5236 : 103 : error ("exporting %q#D that does not have external linkage",
5237 : : binding);
5238 : 103 : if (TREE_CODE (decl) == TYPE_DECL && !DECL_IMPLICIT_TYPEDEF_P (decl))
5239 : : /* An un-exported explicit type alias has no linkage. */
5240 : 18 : inform (DECL_SOURCE_LOCATION (binding),
5241 : : "%q#D declared here with no linkage", binding);
5242 : 85 : else if (internal_p)
5243 : 41 : inform (DECL_SOURCE_LOCATION (binding),
5244 : : "%q#D declared here with internal linkage", binding);
5245 : : else
5246 : 44 : inform (DECL_SOURCE_LOCATION (binding),
5247 : : "%q#D declared here with module linkage", binding);
5248 : 103 : return false;
5249 : 103 : }
5250 : :
5251 : : return true;
5252 : : }
5253 : :
5254 : : /* Process a local-scope or namespace-scope using declaration. LOOKUP
5255 : : is the result of qualified lookup (both value & type are
5256 : : significant). FN_SCOPE_P indicates if we're at function-scope (as
5257 : : opposed to namespace-scope). *VALUE_P and *TYPE_P are the current
5258 : : bindings, which are altered to reflect the newly brought in
5259 : : declarations. */
5260 : :
5261 : : static bool
5262 : 6363989 : do_nonmember_using_decl (name_lookup &lookup, bool fn_scope_p,
5263 : : bool insert_p, tree *value_p, tree *type_p)
5264 : : {
5265 : 6363989 : tree value = *value_p;
5266 : 6363989 : tree type = *type_p;
5267 : 6363989 : bool failed = false;
5268 : :
5269 : : /* Shift the old and new bindings around so we're comparing class and
5270 : : enumeration names to each other. */
5271 : 6363989 : if (value && DECL_IMPLICIT_TYPEDEF_P (strip_using_decl (value)))
5272 : : {
5273 : : type = value;
5274 : : value = NULL_TREE;
5275 : : }
5276 : :
5277 : 6363989 : if (lookup.value && DECL_IMPLICIT_TYPEDEF_P (lookup.value))
5278 : : {
5279 : 114043 : lookup.type = lookup.value;
5280 : 114043 : lookup.value = NULL_TREE;
5281 : : }
5282 : :
5283 : : /* Only process exporting if we're going to be inserting. */
5284 : 6363989 : bool revealing_p = insert_p && !fn_scope_p && module_has_cmi_p ();
5285 : :
5286 : : /* First do the value binding. */
5287 : 6363989 : if (!lookup.value)
5288 : : /* Nothing (only implicit typedef found). */
5289 : 114043 : gcc_checking_assert (lookup.type);
5290 : 6249946 : else if (OVL_P (lookup.value) && (!value || OVL_P (value)))
5291 : : {
5292 : 13427148 : for (lkp_iterator usings (lookup.value); usings; ++usings)
5293 : : {
5294 : 8205812 : tree new_fn = *usings;
5295 : 8205812 : tree inner = STRIP_TEMPLATE (new_fn);
5296 : 8205812 : bool exporting_p = revealing_p && module_exporting_p ();
5297 : 15127 : if (exporting_p)
5298 : 15127 : exporting_p = check_can_export_using_decl (new_fn);
5299 : :
5300 : : /* [namespace.udecl]
5301 : :
5302 : : If a function declaration in namespace scope or block
5303 : : scope has the same name and the same parameter types as a
5304 : : function introduced by a using declaration the program is
5305 : : ill-formed. */
5306 : : /* This seems overreaching, asking core -- why do we care
5307 : : about decls in the namespace that we cannot name (because
5308 : : they are not transitively imported. We just check the
5309 : : decls that are in this TU. */
5310 : 8205812 : bool found = false;
5311 : 102839389 : for (ovl_iterator old (value); !found && old; ++old)
5312 : : {
5313 : 47591324 : tree old_fn = *old;
5314 : :
5315 : 47591324 : if (new_fn == old_fn)
5316 : : {
5317 : : /* The function already exists in the current
5318 : : namespace. We will still want to insert it if
5319 : : it is revealing a not-revealed thing. */
5320 : 262168 : found = true;
5321 : 262168 : if (!revealing_p)
5322 : : ;
5323 : 672 : else if (old.using_p ())
5324 : : {
5325 : : /* Update in place. 'tis ok. */
5326 : 633 : OVL_PURVIEW_P (old.get_using ()) = true;
5327 : 633 : if (exporting_p)
5328 : 627 : OVL_EXPORT_P (old.get_using ()) = true;
5329 : : }
5330 : 39 : else if (!DECL_LANG_SPECIFIC (inner)
5331 : 78 : || !DECL_MODULE_PURVIEW_P (inner))
5332 : : /* We need to re-insert this function as a revealed
5333 : : (possibly exported) declaration. We can't remove
5334 : : the existing decl because that will change any
5335 : : overloads cached in template functions. */
5336 : : found = false;
5337 : : break;
5338 : : }
5339 : 47329156 : else if (old.using_p ())
5340 : 44145829 : continue; /* This is a using decl. */
5341 : 3183327 : else if (old.hidden_p () && DECL_IS_UNDECLARED_BUILTIN (old_fn))
5342 : 2802736 : continue; /* This is an anticipated builtin. */
5343 : 380591 : else if (!matching_fn_p (new_fn, old_fn))
5344 : 380555 : continue; /* Parameters do not match. */
5345 : 36 : else if (decls_match (new_fn, old_fn))
5346 : : {
5347 : : /* Extern "C" in different namespaces. But similarly
5348 : : to above, if revealing a not-revealed thing we may
5349 : : need to reinsert. */
5350 : 15 : found = true;
5351 : 15 : if (revealing_p
5352 : 15 : && (!DECL_LANG_SPECIFIC (inner)
5353 : 3 : || !DECL_MODULE_PURVIEW_P (inner)))
5354 : : found = false;
5355 : : break;
5356 : : }
5357 : : else
5358 : : {
5359 : 21 : diagnose_name_conflict (new_fn, old_fn);
5360 : 21 : failed = true;
5361 : 21 : found = true;
5362 : 21 : break;
5363 : : }
5364 : : }
5365 : :
5366 : 8205812 : if (!found && insert_p)
5367 : : /* Unlike the decl-pushing case we don't drop anticipated
5368 : : builtins here. They don't cause a problem, and we'd
5369 : : like to match them with a future declaration. */
5370 : 7943635 : value = ovl_insert (new_fn, value, 1 + revealing_p + exporting_p);
5371 : : }
5372 : 5221336 : }
5373 : 1028610 : else if (value
5374 : : /* Ignore anticipated builtins. */
5375 : 34123 : && !anticipated_builtin_p (value)
5376 : 1062730 : && (fn_scope_p
5377 : 34105 : || !decls_match (lookup.value, strip_using_decl (value))))
5378 : : {
5379 : 21 : diagnose_name_conflict (lookup.value, value);
5380 : 21 : failed = true;
5381 : : }
5382 : 1028589 : else if (insert_p)
5383 : : {
5384 : : /* A using-decl does not necessarily have the same purview-ness or
5385 : : exporting as the declaration it reveals, so build a USING_DECL
5386 : : that we can attach this information to. This also gives us a
5387 : : location for the using-decl that we can use in diagnostics.
5388 : :
5389 : : But this is unnecessary if we're just redeclaring the same decl;
5390 : : in that case we can just mark it purview or exported directly. */
5391 : 1028577 : if (value != lookup.value)
5392 : : {
5393 : 1024314 : value = build_lang_decl (USING_DECL, lookup.name, NULL_TREE);
5394 : 1024314 : USING_DECL_DECLS (value) = lookup.value;
5395 : 1024314 : USING_DECL_SCOPE (value) = CP_DECL_CONTEXT (lookup.value);
5396 : 1024314 : DECL_CONTEXT (value) = current_scope ();
5397 : 1024314 : DECL_MODULE_PURVIEW_P (value) = module_purview_p ();
5398 : : }
5399 : : else
5400 : 4263 : set_instantiating_module (value);
5401 : :
5402 : 1028577 : if (revealing_p
5403 : 1944 : && module_exporting_p ()
5404 : 1030521 : && check_can_export_using_decl (lookup.value))
5405 : : {
5406 : 1886 : if (TREE_CODE (value) == TEMPLATE_DECL)
5407 : 14 : DECL_MODULE_EXPORT_P (DECL_TEMPLATE_RESULT (value)) = true;
5408 : 1886 : DECL_MODULE_EXPORT_P (value) = true;
5409 : : }
5410 : : }
5411 : :
5412 : : /* Now the type binding. */
5413 : 6363989 : if (lookup.type)
5414 : : {
5415 : 114062 : if (type && !decls_match (lookup.type, strip_using_decl (type)))
5416 : : {
5417 : 3 : diagnose_name_conflict (lookup.type, type);
5418 : 3 : failed = true;
5419 : : }
5420 : 114059 : else if (insert_p)
5421 : : {
5422 : : /* As with revealing value bindings. */
5423 : 114059 : if (type != lookup.type)
5424 : : {
5425 : 114044 : type = build_lang_decl (USING_DECL, lookup.name, NULL_TREE);
5426 : 114044 : USING_DECL_DECLS (type) = lookup.type;
5427 : 114044 : USING_DECL_SCOPE (type) = CP_DECL_CONTEXT (lookup.type);
5428 : 114044 : DECL_CONTEXT (type) = current_scope ();
5429 : 114044 : DECL_MODULE_PURVIEW_P (type) = module_purview_p ();
5430 : : }
5431 : : else
5432 : 15 : set_instantiating_module (type);
5433 : :
5434 : 114059 : if (revealing_p
5435 : 238 : && module_exporting_p ()
5436 : 114288 : && check_can_export_using_decl (lookup.type))
5437 : 217 : DECL_MODULE_EXPORT_P (type) = true;
5438 : : }
5439 : : }
5440 : :
5441 : 6363989 : if (insert_p)
5442 : : {
5443 : : /* If value is empty, shift any class or enumeration name back. */
5444 : 6363968 : if (!value)
5445 : : {
5446 : 114034 : value = type;
5447 : 114034 : type = NULL_TREE;
5448 : : }
5449 : 6363968 : *value_p = value;
5450 : 6363968 : *type_p = type;
5451 : : }
5452 : :
5453 : 6363989 : return failed;
5454 : : }
5455 : :
5456 : : /* Returns true if ANCESTOR encloses DESCENDANT, including matching.
5457 : : Both are namespaces. */
5458 : :
5459 : : bool
5460 : 106303048 : is_nested_namespace (tree ancestor, tree descendant, bool inline_only)
5461 : : {
5462 : 106303048 : int depth = SCOPE_DEPTH (ancestor);
5463 : :
5464 : 106303048 : if (!depth && !inline_only)
5465 : : /* The global namespace encloses everything. */
5466 : : return true;
5467 : :
5468 : 108233837 : while (SCOPE_DEPTH (descendant) > depth
5469 : 108233837 : && (!inline_only || DECL_NAMESPACE_INLINE_P (descendant)))
5470 : 2020995 : descendant = CP_DECL_CONTEXT (descendant);
5471 : :
5472 : 106212842 : return ancestor == descendant;
5473 : : }
5474 : :
5475 : : /* Returns true if ROOT (a non-alias namespace, class, or function)
5476 : : encloses CHILD. CHILD may be either a class type or a namespace
5477 : : (maybe alias). */
5478 : :
5479 : : bool
5480 : 78700327 : is_ancestor (tree root, tree child)
5481 : : {
5482 : 78700327 : gcc_checking_assert ((TREE_CODE (root) == NAMESPACE_DECL
5483 : : && !DECL_NAMESPACE_ALIAS (root))
5484 : : || TREE_CODE (root) == FUNCTION_DECL
5485 : : || CLASS_TYPE_P (root));
5486 : 78700327 : gcc_checking_assert (TREE_CODE (child) == NAMESPACE_DECL
5487 : : || CLASS_TYPE_P (child));
5488 : :
5489 : : /* The global namespace encloses everything. Early-out for the
5490 : : common case. */
5491 : 78700327 : if (root == global_namespace)
5492 : : return true;
5493 : :
5494 : : /* Search CHILD until we reach namespace scope. */
5495 : 163105402 : while (TREE_CODE (child) != NAMESPACE_DECL)
5496 : : {
5497 : : /* If we've reached the ROOT, it encloses CHILD. */
5498 : 84660354 : if (root == child)
5499 : : return true;
5500 : :
5501 : : /* Go out one level. */
5502 : 84660303 : if (TYPE_P (child))
5503 : 83760728 : child = TYPE_NAME (child);
5504 : 84660303 : child = CP_DECL_CONTEXT (child);
5505 : : }
5506 : :
5507 : 78445048 : if (TREE_CODE (root) != NAMESPACE_DECL)
5508 : : /* Failed to meet the non-namespace we were looking for. */
5509 : : return false;
5510 : :
5511 : 78445033 : if (tree alias = DECL_NAMESPACE_ALIAS (child))
5512 : 3 : child = alias;
5513 : :
5514 : 78445033 : return is_nested_namespace (root, child);
5515 : : }
5516 : :
5517 : : /* Enter the class or namespace scope indicated by T suitable for name
5518 : : lookup. T can be arbitrary scope, not necessary nested inside the
5519 : : current scope. Returns a non-null scope to pop iff pop_scope
5520 : : should be called later to exit this scope. */
5521 : :
5522 : : tree
5523 : 292888188 : push_scope (tree t)
5524 : : {
5525 : 292888188 : if (TREE_CODE (t) == NAMESPACE_DECL)
5526 : 68840246 : push_decl_namespace (t);
5527 : 224047942 : else if (CLASS_TYPE_P (t))
5528 : : {
5529 : 161585654 : if (!at_class_scope_p ()
5530 : 161585654 : || !same_type_p (current_class_type, t))
5531 : 75743483 : push_nested_class (t);
5532 : : else
5533 : : /* T is the same as the current scope. There is therefore no
5534 : : need to re-enter the scope. Since we are not actually
5535 : : pushing a new scope, our caller should not call
5536 : : pop_scope. */
5537 : : t = NULL_TREE;
5538 : : }
5539 : :
5540 : 292888188 : return t;
5541 : : }
5542 : :
5543 : : /* Leave scope pushed by push_scope. */
5544 : :
5545 : : void
5546 : 207046486 : pop_scope (tree t)
5547 : : {
5548 : 207046486 : if (t == NULL_TREE)
5549 : : return;
5550 : 207046014 : if (TREE_CODE (t) == NAMESPACE_DECL)
5551 : 68840243 : pop_decl_namespace ();
5552 : 138205771 : else if CLASS_TYPE_P (t)
5553 : 75743483 : pop_nested_class ();
5554 : : }
5555 : :
5556 : : /* Subroutine of push_inner_scope. */
5557 : :
5558 : : static void
5559 : 250766 : push_inner_scope_r (tree outer, tree inner)
5560 : : {
5561 : 250766 : tree prev;
5562 : :
5563 : 250766 : if (outer == inner
5564 : 250766 : || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
5565 : : return;
5566 : :
5567 : 250757 : prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
5568 : 250757 : if (outer != prev)
5569 : 2533 : push_inner_scope_r (outer, prev);
5570 : 250757 : if (TREE_CODE (inner) == NAMESPACE_DECL)
5571 : : {
5572 : : cp_binding_level *save_template_parm = 0;
5573 : : /* Temporary take out template parameter scopes. They are saved
5574 : : in reversed order in save_template_parm. */
5575 : 60027 : while (current_binding_level->kind == sk_template_parms)
5576 : : {
5577 : 29946 : cp_binding_level *b = current_binding_level;
5578 : 29946 : current_binding_level = b->level_chain;
5579 : 29946 : b->level_chain = save_template_parm;
5580 : 29946 : save_template_parm = b;
5581 : : }
5582 : :
5583 : 30081 : resume_scope (NAMESPACE_LEVEL (inner));
5584 : 30081 : current_namespace = inner;
5585 : :
5586 : : /* Restore template parameter scopes. */
5587 : 60027 : while (save_template_parm)
5588 : : {
5589 : 29946 : cp_binding_level *b = save_template_parm;
5590 : 29946 : save_template_parm = b->level_chain;
5591 : 29946 : b->level_chain = current_binding_level;
5592 : 29946 : current_binding_level = b;
5593 : : }
5594 : : }
5595 : : else
5596 : 220676 : pushclass (inner);
5597 : : }
5598 : :
5599 : : /* Enter the scope INNER from current scope. INNER must be a scope
5600 : : nested inside current scope. This works with both name lookup and
5601 : : pushing name into scope. In case a template parameter scope is present,
5602 : : namespace is pushed under the template parameter scope according to
5603 : : name lookup rule in 14.6.1/6.
5604 : :
5605 : : Return the former current scope suitable for pop_inner_scope. */
5606 : :
5607 : : tree
5608 : 248233 : push_inner_scope (tree inner)
5609 : : {
5610 : 248233 : tree outer = current_scope ();
5611 : 248233 : if (!outer)
5612 : 0 : outer = current_namespace;
5613 : :
5614 : 248233 : push_inner_scope_r (outer, inner);
5615 : 248233 : return outer;
5616 : : }
5617 : :
5618 : : /* Exit the current scope INNER back to scope OUTER. */
5619 : :
5620 : : void
5621 : 248233 : pop_inner_scope (tree outer, tree inner)
5622 : : {
5623 : 248233 : if (outer == inner
5624 : 248233 : || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
5625 : : return;
5626 : :
5627 : 498984 : while (outer != inner)
5628 : : {
5629 : 250760 : if (TREE_CODE (inner) == NAMESPACE_DECL)
5630 : : {
5631 : : cp_binding_level *save_template_parm = 0;
5632 : : /* Temporary take out template parameter scopes. They are saved
5633 : : in reversed order in save_template_parm. */
5634 : 60027 : while (current_binding_level->kind == sk_template_parms)
5635 : : {
5636 : 29946 : cp_binding_level *b = current_binding_level;
5637 : 29946 : current_binding_level = b->level_chain;
5638 : 29946 : b->level_chain = save_template_parm;
5639 : 29946 : save_template_parm = b;
5640 : : }
5641 : :
5642 : 30081 : pop_namespace ();
5643 : :
5644 : : /* Restore template parameter scopes. */
5645 : 90108 : while (save_template_parm)
5646 : : {
5647 : 29946 : cp_binding_level *b = save_template_parm;
5648 : 29946 : save_template_parm = b->level_chain;
5649 : 29946 : b->level_chain = current_binding_level;
5650 : 29946 : current_binding_level = b;
5651 : : }
5652 : : }
5653 : : else
5654 : 220679 : popclass ();
5655 : :
5656 : 250757 : inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
5657 : : }
5658 : : }
5659 : :
5660 : : /* Do a pushlevel for class declarations. */
5661 : :
5662 : : void
5663 : 172835246 : pushlevel_class (void)
5664 : : {
5665 : 172835246 : class_binding_level = begin_scope (sk_class, current_class_type);
5666 : 172835246 : }
5667 : :
5668 : : /* ...and a poplevel for class declarations. */
5669 : :
5670 : : void
5671 : 341628304 : poplevel_class (void)
5672 : : {
5673 : 341628304 : cp_binding_level *level = class_binding_level;
5674 : 341628304 : cp_class_binding *cb;
5675 : 341628304 : size_t i;
5676 : 341628304 : tree shadowed;
5677 : :
5678 : 341628304 : auto_cond_timevar tv (TV_NAME_LOOKUP);
5679 : 341628304 : gcc_assert (level != 0);
5680 : :
5681 : : /* If we're leaving a toplevel class, cache its binding level. */
5682 : 341628301 : if (current_class_depth == 1)
5683 : 219392421 : previous_class_level = level;
5684 : 341628301 : for (shadowed = level->type_shadowed;
5685 : 1204136983 : shadowed;
5686 : 862508682 : shadowed = TREE_CHAIN (shadowed))
5687 : 862508682 : SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
5688 : :
5689 : : /* Remove the bindings for all of the class-level declarations. */
5690 : 341628301 : if (level->class_shadowed)
5691 : : {
5692 : 512429497 : FOR_EACH_VEC_ELT (*level->class_shadowed, i, cb)
5693 : : {
5694 : 392992407 : IDENTIFIER_BINDING (cb->identifier) = cb->base->previous;
5695 : 392992407 : cxx_binding_free (cb->base);
5696 : : }
5697 : 119437090 : ggc_free (level->class_shadowed);
5698 : 119437090 : level->class_shadowed = NULL;
5699 : : }
5700 : :
5701 : : /* Now, pop out of the binding level which we created up in the
5702 : : `pushlevel_class' routine. */
5703 : 341628301 : gcc_assert (current_binding_level == level);
5704 : 341628301 : leave_scope ();
5705 : 341628301 : }
5706 : :
5707 : : /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
5708 : : appropriate. DECL is the value to which a name has just been
5709 : : bound. CLASS_TYPE is the class in which the lookup occurred. */
5710 : :
5711 : : static void
5712 : 132856769 : set_inherited_value_binding_p (cxx_binding *binding, tree decl,
5713 : : tree class_type)
5714 : : {
5715 : 132856769 : if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
5716 : : {
5717 : 132298263 : tree context;
5718 : :
5719 : 132298263 : if (is_overloaded_fn (decl))
5720 : 38391077 : context = ovl_scope (decl);
5721 : : else
5722 : : {
5723 : 93907186 : gcc_assert (DECL_P (decl));
5724 : 93907186 : context = context_for_name_lookup (decl);
5725 : : }
5726 : :
5727 : 132298263 : if (is_properly_derived_from (class_type, context))
5728 : 16762998 : INHERITED_VALUE_BINDING_P (binding) = 1;
5729 : : else
5730 : 115535265 : INHERITED_VALUE_BINDING_P (binding) = 0;
5731 : : }
5732 : 558506 : else if (binding->value == decl)
5733 : : /* We only encounter a TREE_LIST when there is an ambiguity in the
5734 : : base classes. Such an ambiguity can be overridden by a
5735 : : definition in this class. */
5736 : 558506 : INHERITED_VALUE_BINDING_P (binding) = 1;
5737 : : else
5738 : 0 : INHERITED_VALUE_BINDING_P (binding) = 0;
5739 : 132856769 : }
5740 : :
5741 : : /* Make the declaration of X appear in CLASS scope. */
5742 : :
5743 : : bool
5744 : 150788169 : pushdecl_class_level (tree x)
5745 : : {
5746 : 150788169 : bool is_valid = true;
5747 : :
5748 : : /* Do nothing if we're adding to an outer lambda closure type,
5749 : : outer_binding will add it later if it's needed. */
5750 : 150788169 : if (current_class_type != class_binding_level->this_entity)
5751 : : return true;
5752 : :
5753 : 150788169 : auto_cond_timevar tv (TV_NAME_LOOKUP);
5754 : : /* Get the name of X. */
5755 : 301576338 : tree name = OVL_NAME (x);
5756 : :
5757 : 150788169 : if (name)
5758 : : {
5759 : 150494857 : is_valid = push_class_level_binding (name, x);
5760 : 150494857 : if (TREE_CODE (x) == TYPE_DECL)
5761 : 108273910 : set_identifier_type_value (name, x);
5762 : : }
5763 : 293312 : else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
5764 : : {
5765 : : /* If X is an anonymous aggregate, all of its members are
5766 : : treated as if they were members of the class containing the
5767 : : aggregate, for naming purposes. */
5768 : 158424 : location_t save_location = input_location;
5769 : 158424 : tree anon = TREE_TYPE (x);
5770 : 158424 : if (vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (anon))
5771 : 201475 : for (unsigned ix = member_vec->length (); ix--;)
5772 : : {
5773 : 185559 : tree binding = (*member_vec)[ix];
5774 : 185559 : if (STAT_HACK_P (binding))
5775 : : {
5776 : 0 : if (!pushdecl_class_level (STAT_TYPE (binding)))
5777 : 0 : is_valid = false;
5778 : 0 : binding = STAT_DECL (binding);
5779 : : }
5780 : 185559 : if (!pushdecl_class_level (binding))
5781 : 0 : is_valid = false;
5782 : : }
5783 : : else
5784 : 624322 : for (tree f = TYPE_FIELDS (anon); f; f = DECL_CHAIN (f))
5785 : 481814 : if (TREE_CODE (f) == FIELD_DECL)
5786 : : {
5787 : 306606 : input_location = DECL_SOURCE_LOCATION (f);
5788 : 306606 : if (!pushdecl_class_level (f))
5789 : 481814 : is_valid = false;
5790 : : }
5791 : 158424 : input_location = save_location;
5792 : : }
5793 : 150788169 : return is_valid;
5794 : 150788169 : }
5795 : :
5796 : : /* Return the BINDING (if any) for NAME in SCOPE, which is a class
5797 : : scope. If the value returned is non-NULL, and the PREVIOUS field
5798 : : is not set, callers must set the PREVIOUS field explicitly. */
5799 : :
5800 : : static cxx_binding *
5801 : 1665646500 : get_class_binding (tree name, cp_binding_level *scope)
5802 : : {
5803 : 1665646500 : tree class_type;
5804 : 1665646500 : tree type_binding;
5805 : 1665646500 : tree value_binding;
5806 : 1665646500 : cxx_binding *binding;
5807 : :
5808 : 1665646500 : class_type = scope->this_entity;
5809 : :
5810 : : /* Get the type binding. */
5811 : 1665646500 : type_binding = lookup_member (class_type, name,
5812 : : /*protect=*/2, /*want_type=*/true,
5813 : : tf_warning_or_error);
5814 : : /* Get the value binding. */
5815 : 1665646500 : value_binding = lookup_member (class_type, name,
5816 : : /*protect=*/2, /*want_type=*/false,
5817 : : tf_warning_or_error);
5818 : :
5819 : : /* If we found either a type binding or a value binding, create a
5820 : : new binding object. */
5821 : 1665646500 : if (type_binding || value_binding)
5822 : : {
5823 : 132856769 : binding = new_class_binding (name,
5824 : : value_binding,
5825 : : type_binding,
5826 : : scope);
5827 : 132856769 : set_inherited_value_binding_p (binding, value_binding, class_type);
5828 : : }
5829 : : else
5830 : : binding = NULL;
5831 : :
5832 : 1665646500 : return binding;
5833 : : }
5834 : :
5835 : : /* Make the declaration(s) of X appear in CLASS scope under the name
5836 : : NAME. Returns true if the binding is valid. */
5837 : :
5838 : : bool
5839 : 380808419 : push_class_level_binding (tree name, tree x)
5840 : : {
5841 : 380808419 : cxx_binding *binding;
5842 : 380808419 : tree decl = x;
5843 : 380808419 : bool ok;
5844 : :
5845 : 380808419 : auto_cond_timevar tv (TV_NAME_LOOKUP);
5846 : :
5847 : : /* The class_binding_level will be NULL if x is a template
5848 : : parameter name in a member template. */
5849 : 380808419 : if (!class_binding_level)
5850 : : return true;
5851 : :
5852 : 380808419 : if (name == error_mark_node)
5853 : : return false;
5854 : :
5855 : : /* Can happen for an erroneous declaration (c++/60384). */
5856 : 380808419 : if (!identifier_p (name))
5857 : : {
5858 : 3 : gcc_assert (errorcount || sorrycount);
5859 : : return false;
5860 : : }
5861 : :
5862 : : /* Check for invalid member names. But don't worry about a default
5863 : : argument-scope lambda being pushed after the class is complete. */
5864 : 380808431 : gcc_assert (TYPE_BEING_DEFINED (current_class_type)
5865 : : || LAMBDA_TYPE_P (TREE_TYPE (decl)));
5866 : : /* Check that we're pushing into the right binding level. */
5867 : 380808416 : gcc_assert (current_class_type == class_binding_level->this_entity);
5868 : :
5869 : : /* We could have been passed a tree list if this is an ambiguous
5870 : : declaration. If so, pull the declaration out because
5871 : : check_template_shadow will not handle a TREE_LIST. */
5872 : 380808416 : if (TREE_CODE (decl) == TREE_LIST
5873 : 380808416 : && TREE_TYPE (decl) == error_mark_node)
5874 : 0 : decl = TREE_VALUE (decl);
5875 : :
5876 : 380808416 : if (!check_template_shadow (decl))
5877 : : return false;
5878 : :
5879 : : /* [class.mem]
5880 : :
5881 : : If T is the name of a class, then each of the following shall
5882 : : have a name different from T:
5883 : :
5884 : : -- every static data member of class T;
5885 : :
5886 : : -- every member of class T that is itself a type;
5887 : :
5888 : : -- every enumerator of every member of class T that is an
5889 : : enumerated type;
5890 : :
5891 : : -- every member of every anonymous union that is a member of
5892 : : class T.
5893 : :
5894 : : (Non-static data members were also forbidden to have the same
5895 : : name as T until TC1.) */
5896 : 380808377 : if ((VAR_P (x)
5897 : 380808377 : || TREE_CODE (x) == CONST_DECL
5898 : 366854523 : || (TREE_CODE (x) == TYPE_DECL
5899 : 108273895 : && !DECL_SELF_REFERENCE_P (x))
5900 : : /* A data member of an anonymous union. */
5901 : 310019630 : || (TREE_CODE (x) == FIELD_DECL
5902 : 22079105 : && DECL_CONTEXT (x) != current_class_type))
5903 : 438098435 : && DECL_NAME (x) == DECL_NAME (TYPE_NAME (current_class_type)))
5904 : : {
5905 : 24 : tree scope = context_for_name_lookup (x);
5906 : 24 : if (TYPE_P (scope) && same_type_p (scope, current_class_type))
5907 : : {
5908 : 24 : error_at (DECL_SOURCE_LOCATION (x),
5909 : : "%qD has the same name as the class in which it is "
5910 : : "declared", x);
5911 : 24 : return false;
5912 : : }
5913 : : }
5914 : :
5915 : : /* Get the current binding for NAME in this class, if any. */
5916 : 380808353 : binding = IDENTIFIER_BINDING (name);
5917 : 380808353 : if (!binding || binding->scope != class_binding_level)
5918 : : {
5919 : 271170956 : binding = get_class_binding (name, class_binding_level);
5920 : : /* If a new binding was created, put it at the front of the
5921 : : IDENTIFIER_BINDING list. */
5922 : 271170956 : if (binding)
5923 : : {
5924 : 11032480 : binding->previous = IDENTIFIER_BINDING (name);
5925 : 11032480 : IDENTIFIER_BINDING (name) = binding;
5926 : : }
5927 : : }
5928 : :
5929 : : /* If there is already a binding, then we may need to update the
5930 : : current value. */
5931 : 120669877 : if (binding && binding->value)
5932 : : {
5933 : 120669877 : tree bval = binding->value;
5934 : 120669877 : tree old_decl = NULL_TREE;
5935 : 120669877 : tree target_decl = strip_using_decl (decl);
5936 : 120669877 : tree target_bval = strip_using_decl (bval);
5937 : :
5938 : 120669877 : if (INHERITED_VALUE_BINDING_P (binding))
5939 : : {
5940 : : /* If the old binding was from a base class, and was for a
5941 : : tag name, slide it over to make room for the new binding.
5942 : : The old binding is still visible if explicitly qualified
5943 : : with a class-key. */
5944 : 13161066 : if (TREE_CODE (target_bval) == TYPE_DECL
5945 : 6785342 : && DECL_ARTIFICIAL (target_bval)
5946 : 13752843 : && !(TREE_CODE (target_decl) == TYPE_DECL
5947 : 591768 : && DECL_ARTIFICIAL (target_decl)))
5948 : : {
5949 : 66995 : old_decl = binding->type;
5950 : 66995 : binding->type = bval;
5951 : 66995 : binding->value = NULL_TREE;
5952 : 66995 : INHERITED_VALUE_BINDING_P (binding) = 0;
5953 : : }
5954 : : else
5955 : : {
5956 : 13094071 : old_decl = bval;
5957 : : /* Any inherited type declaration is hidden by the type
5958 : : declaration in the derived class. */
5959 : 13094071 : if (TREE_CODE (target_decl) == TYPE_DECL
5960 : 13094071 : && DECL_ARTIFICIAL (target_decl))
5961 : 525282 : binding->type = NULL_TREE;
5962 : : }
5963 : : }
5964 : 107508811 : else if (TREE_CODE (decl) == USING_DECL
5965 : 3431 : && TREE_CODE (bval) == USING_DECL
5966 : 107508917 : && same_type_p (USING_DECL_SCOPE (decl),
5967 : : USING_DECL_SCOPE (bval)))
5968 : : /* This is a using redeclaration that will be diagnosed later
5969 : : in supplement_binding */
5970 : : ;
5971 : 107508778 : else if (TREE_CODE (decl) == USING_DECL
5972 : 3398 : && TREE_CODE (bval) == USING_DECL
5973 : 73 : && DECL_DEPENDENT_P (decl)
5974 : 107508797 : && DECL_DEPENDENT_P (bval))
5975 : : return true;
5976 : 107508759 : else if (TREE_CODE (decl) == USING_DECL
5977 : 3379 : && DECL_DEPENDENT_P (decl)
5978 : 107511899 : && OVL_P (target_bval))
5979 : : /* The new dependent using beats an old overload. */
5980 : : old_decl = bval;
5981 : 107505619 : else if (TREE_CODE (bval) == USING_DECL
5982 : 738814 : && DECL_DEPENDENT_P (bval)
5983 : 107894061 : && OVL_P (target_decl))
5984 : : /* The old dependent using beats a new overload. */
5985 : : return true;
5986 : 107117189 : else if (OVL_P (target_decl)
5987 : 106799327 : && OVL_P (target_bval))
5988 : : /* The new overload set contains the old one. */
5989 : : old_decl = bval;
5990 : :
5991 : 119963509 : if (old_decl && binding->scope == class_binding_level)
5992 : : {
5993 : 119963509 : binding->value = x;
5994 : : /* It is always safe to clear INHERITED_VALUE_BINDING_P
5995 : : here. This function is only used to register bindings
5996 : : from with the class definition itself. */
5997 : 119963509 : INHERITED_VALUE_BINDING_P (binding) = 0;
5998 : 119963509 : return true;
5999 : : }
6000 : : }
6001 : :
6002 : : /* Note that we declared this value so that we can issue an error if
6003 : : this is an invalid redeclaration of a name already used for some
6004 : : other purpose. */
6005 : 260456395 : note_name_declared_in_class (name, decl);
6006 : :
6007 : : /* If we didn't replace an existing binding, put the binding on the
6008 : : stack of bindings for the identifier, and update the shadowed
6009 : : list. */
6010 : 260456395 : if (binding && binding->scope == class_binding_level)
6011 : : /* Supplement the existing binding. */
6012 : 317919 : ok = supplement_binding (binding, decl);
6013 : : else
6014 : : {
6015 : : /* Create a new binding. */
6016 : 260138476 : push_binding (name, decl, class_binding_level);
6017 : 260138476 : ok = true;
6018 : : }
6019 : :
6020 : : return ok;
6021 : 380808419 : }
6022 : :
6023 : : /* Process and lookup a using decl SCOPE::lookup.name, filling in
6024 : : lookup.values & lookup.type. Return a USING_DECL, or NULL_TREE on
6025 : : failure. */
6026 : :
6027 : : static tree
6028 : 8850600 : lookup_using_decl (tree scope, name_lookup &lookup)
6029 : : {
6030 : 8850600 : tree current = current_scope ();
6031 : 8850600 : bool dependent_p = false;
6032 : 8850600 : tree binfo = NULL_TREE;
6033 : 8850600 : base_kind b_kind = bk_not_base;
6034 : :
6035 : : /* Because C++20 breaks the invariant that only member using-decls
6036 : : refer to members and only non-member using-decls refer to
6037 : : non-members, we first do the lookups, and then do validation that
6038 : : what we found is ok. */
6039 : :
6040 : 8850600 : if (TREE_CODE (scope) == ENUMERAL_TYPE
6041 : 413981 : && cxx_dialect < cxx20
6042 : 413981 : && UNSCOPED_ENUM_P (scope)
6043 : 8850618 : && !TYPE_FUNCTION_SCOPE_P (scope))
6044 : : {
6045 : : /* PR c++/60265 argued that since C++11 added explicit enum scope, we
6046 : : should allow it as meaning the enclosing scope. I don't see any
6047 : : justification for this in C++11, but let's keep allowing it. */
6048 : 16 : tree ctx = CP_TYPE_CONTEXT (scope);
6049 : 42 : if (CLASS_TYPE_P (ctx) == CLASS_TYPE_P (current))
6050 : 8850600 : scope = ctx;
6051 : : }
6052 : :
6053 : : /* You cannot using-decl a destructor. */
6054 : 8850600 : if (TREE_CODE (lookup.name) == BIT_NOT_EXPR)
6055 : : {
6056 : 6 : error ("%<%T%s%D%> names destructor", scope,
6057 : 3 : &"::"[scope == global_namespace ? 2 : 0], lookup.name);
6058 : 3 : return NULL_TREE;
6059 : : }
6060 : :
6061 : 8850597 : if (TREE_CODE (scope) == NAMESPACE_DECL)
6062 : : {
6063 : : /* Naming a namespace member. */
6064 : 6251449 : qualified_namespace_lookup (scope, &lookup);
6065 : :
6066 : 6251449 : if (TYPE_P (current)
6067 : 3 : && (!lookup.value
6068 : 0 : || lookup.type
6069 : 0 : || cxx_dialect < cxx20
6070 : 0 : || TREE_CODE (lookup.value) != CONST_DECL))
6071 : : {
6072 : 3 : error ("using-declaration for non-member at class scope");
6073 : 3 : return NULL_TREE;
6074 : : }
6075 : : }
6076 : 2599148 : else if (TREE_CODE (scope) == ENUMERAL_TYPE)
6077 : : {
6078 : : /* Naming an enumeration member. */
6079 : 413966 : if (cxx_dialect < cxx20)
6080 : 12 : error ("%<using%> with enumeration scope %q#T "
6081 : : "only available with %<-std=c++20%> or %<-std=gnu++20%>",
6082 : : scope);
6083 : 413966 : lookup.value = lookup_enumerator (scope, lookup.name);
6084 : : }
6085 : : else
6086 : : {
6087 : : /* Naming a class member. This is awkward in C++20, because we
6088 : : might be naming an enumerator of an unrelated class. */
6089 : :
6090 : 2185182 : tree npscope = scope;
6091 : 2185182 : if (PACK_EXPANSION_P (scope))
6092 : 9594 : npscope = PACK_EXPANSION_PATTERN (scope);
6093 : :
6094 : 2185182 : if (!MAYBE_CLASS_TYPE_P (npscope))
6095 : : {
6096 : 9 : error ("%qT is not a class, namespace, or enumeration", npscope);
6097 : 9 : return NULL_TREE;
6098 : : }
6099 : :
6100 : : /* Using T::T declares inheriting ctors, even if T is a typedef. */
6101 : 2185173 : if (lookup.name == TYPE_IDENTIFIER (npscope)
6102 : 2185173 : || constructor_name_p (lookup.name, npscope))
6103 : : {
6104 : 210278 : if (!TYPE_P (current))
6105 : : {
6106 : 0 : error ("non-member using-declaration names constructor of %qT",
6107 : : npscope);
6108 : 0 : return NULL_TREE;
6109 : : }
6110 : 210278 : maybe_warn_cpp0x (CPP0X_INHERITING_CTORS);
6111 : 210278 : lookup.name = ctor_identifier;
6112 : 210278 : CLASSTYPE_NON_AGGREGATE (current) = true;
6113 : : }
6114 : :
6115 : 2185173 : if (!TYPE_P (current) && cxx_dialect < cxx20)
6116 : : {
6117 : 4 : error ("using-declaration for member at non-class scope");
6118 : 4 : return NULL_TREE;
6119 : : }
6120 : :
6121 : 2185169 : bool depscope = dependent_scope_p (scope);
6122 : :
6123 : 2185169 : if (depscope)
6124 : : /* Leave binfo null. */;
6125 : 1602604 : else if (TYPE_P (current))
6126 : : {
6127 : 1602591 : binfo = lookup_base (current, scope, ba_any, &b_kind, tf_none);
6128 : 1602591 : gcc_checking_assert (b_kind >= bk_not_base);
6129 : :
6130 : 1602591 : if (b_kind == bk_not_base && any_dependent_bases_p ())
6131 : : /* Treat as-if dependent. */
6132 : : depscope = true;
6133 : 1602570 : else if (lookup.name == ctor_identifier
6134 : 1602570 : && (b_kind < bk_proper_base || !binfo_direct_p (binfo)))
6135 : : {
6136 : 15 : if (any_dependent_bases_p ())
6137 : : depscope = true;
6138 : : else
6139 : : {
6140 : 15 : error ("%qT is not a direct base of %qT", scope, current);
6141 : 15 : return NULL_TREE;
6142 : : }
6143 : : }
6144 : :
6145 : 1602576 : if (b_kind < bk_proper_base)
6146 : 50 : binfo = TYPE_BINFO (scope);
6147 : : }
6148 : : else
6149 : 13 : binfo = TYPE_BINFO (scope);
6150 : :
6151 : 3205151 : dependent_p = (depscope
6152 : 1602589 : || (IDENTIFIER_CONV_OP_P (lookup.name)
6153 : 135218 : && dependent_type_p (TREE_TYPE (lookup.name))));
6154 : :
6155 : 1602562 : if (!dependent_p)
6156 : 1602562 : lookup.value = lookup_member (binfo, lookup.name, /*protect=*/2,
6157 : : /*want_type=*/false, tf_none);
6158 : :
6159 : : /* If the lookup in the base contains a dependent using, this
6160 : : using is also dependent. */
6161 : 1602562 : if (!dependent_p && lookup.value && dependent_type_p (scope))
6162 : : {
6163 : 27 : tree val = lookup.value;
6164 : 27 : if (tree fns = maybe_get_fns (val))
6165 : 9 : val = fns;
6166 : 48 : for (tree f: lkp_range (val))
6167 : 27 : if (TREE_CODE (f) == USING_DECL && DECL_DEPENDENT_P (f))
6168 : : {
6169 : : dependent_p = true;
6170 : : break;
6171 : : }
6172 : : }
6173 : :
6174 : 2185154 : if (!depscope && b_kind < bk_proper_base)
6175 : : {
6176 : 42 : if (cxx_dialect >= cxx20 && lookup.value
6177 : 23 : && TREE_CODE (lookup.value) == CONST_DECL)
6178 : : {
6179 : : /* Using an unrelated enum; check access here rather
6180 : : than separately for class and non-class using. */
6181 : 15 : perform_or_defer_access_check
6182 : 15 : (binfo, lookup.value, lookup.value, tf_warning_or_error);
6183 : : /* And then if this is a copy from handle_using_decl, look
6184 : : through to the original enumerator. */
6185 : 15 : if (CONST_DECL_USING_P (lookup.value))
6186 : 6 : lookup.value = DECL_ABSTRACT_ORIGIN (lookup.value);
6187 : : }
6188 : 27 : else if (!TYPE_P (current))
6189 : : {
6190 : 1 : error ("using-declaration for member at non-class scope");
6191 : 1 : return NULL_TREE;
6192 : : }
6193 : : else
6194 : : {
6195 : 26 : auto_diagnostic_group g;
6196 : 26 : error_not_base_type (scope, current);
6197 : 17 : if (lookup.value && DECL_IMPLICIT_TYPEDEF_P (lookup.value)
6198 : 29 : && TREE_CODE (TREE_TYPE (lookup.value)) == ENUMERAL_TYPE)
6199 : 3 : inform (input_location,
6200 : : "did you mean %<using enum %T::%D%>?",
6201 : : scope, lookup.name);
6202 : 26 : return NULL_TREE;
6203 : 26 : }
6204 : : }
6205 : : }
6206 : :
6207 : : /* Did we find anything sane? */
6208 : 2599093 : if (dependent_p)
6209 : : ;
6210 : 8267941 : else if (!lookup.value)
6211 : : {
6212 : 57 : error ("%qD has not been declared in %qD", lookup.name, scope);
6213 : 57 : return NULL_TREE;
6214 : : }
6215 : 8267884 : else if (TREE_CODE (lookup.value) == TREE_LIST
6216 : : /* We can (independently) have ambiguous implicit typedefs. */
6217 : 8267884 : || (lookup.type && TREE_CODE (lookup.type) == TREE_LIST))
6218 : : {
6219 : 3 : auto_diagnostic_group d;
6220 : 3 : error ("reference to %qD is ambiguous", lookup.name);
6221 : 3 : print_candidates (TREE_CODE (lookup.value) == TREE_LIST
6222 : : ? lookup.value : lookup.type);
6223 : 3 : return NULL_TREE;
6224 : 3 : }
6225 : 8267881 : else if (TREE_CODE (lookup.value) == NAMESPACE_DECL)
6226 : : {
6227 : 6 : error ("using-declaration may not name namespace %qD", lookup.value);
6228 : 6 : return NULL_TREE;
6229 : : }
6230 : :
6231 : 8850473 : if (TYPE_P (current))
6232 : : {
6233 : : /* In class scope. */
6234 : :
6235 : : /* Cannot introduce a constructor name. */
6236 : 2486505 : if (constructor_name_p (lookup.name, current))
6237 : : {
6238 : 3 : error ("%<%T::%D%> names constructor in %qT",
6239 : : scope, lookup.name, current);
6240 : 3 : return NULL_TREE;
6241 : : }
6242 : :
6243 : 2486502 : if (lookup.value && BASELINK_P (lookup.value))
6244 : : /* The binfo from which the functions came does not matter. */
6245 : 1438289 : lookup.value = BASELINK_FUNCTIONS (lookup.value);
6246 : : }
6247 : :
6248 : 8850470 : tree using_decl = build_lang_decl (USING_DECL, lookup.name, NULL_TREE);
6249 : 8850470 : USING_DECL_SCOPE (using_decl) = scope;
6250 : 8850470 : USING_DECL_DECLS (using_decl) = lookup.value;
6251 : 8850470 : DECL_DEPENDENT_P (using_decl) = dependent_p;
6252 : 8850470 : DECL_CONTEXT (using_decl) = current;
6253 : 8850470 : if (TYPE_P (current) && b_kind == bk_not_base)
6254 : 884009 : USING_DECL_UNRELATED_P (using_decl) = true;
6255 : :
6256 : : return using_decl;
6257 : : }
6258 : :
6259 : : /* Process "using SCOPE::NAME" in a class scope. Return the
6260 : : USING_DECL created. */
6261 : :
6262 : : tree
6263 : 2486594 : do_class_using_decl (tree scope, tree name)
6264 : : {
6265 : 2486594 : if (name == error_mark_node
6266 : 2486591 : || scope == error_mark_node)
6267 : : return NULL_TREE;
6268 : :
6269 : 2486588 : name_lookup lookup (name);
6270 : 2486588 : return lookup_using_decl (scope, lookup);
6271 : 2486588 : }
6272 : :
6273 : :
6274 : : /* Return the binding for NAME in NS in the current TU. If NS is
6275 : : NULL, look in global_namespace. We will not find declarations
6276 : : from imports. Users of this who, having found nothing, push a new
6277 : : decl must be prepared for that pushing to match an existing decl. */
6278 : :
6279 : : tree
6280 : 9112828 : get_namespace_binding (tree ns, tree name)
6281 : : {
6282 : 9112828 : auto_cond_timevar tv (TV_NAME_LOOKUP);
6283 : 9112828 : if (!ns)
6284 : 9112828 : ns = global_namespace;
6285 : 9112828 : gcc_checking_assert (!DECL_NAMESPACE_ALIAS (ns));
6286 : 9112828 : tree ret = NULL_TREE;
6287 : :
6288 : 9112828 : if (tree *b = find_namespace_slot (ns, name))
6289 : : {
6290 : 4892546 : ret = *b;
6291 : :
6292 : 4892546 : if (TREE_CODE (ret) == BINDING_VECTOR)
6293 : 0 : ret = BINDING_VECTOR_CLUSTER (ret, 0).slots[0];
6294 : 0 : if (ret)
6295 : 4892546 : ret = strip_using_decl (MAYBE_STAT_DECL (ret));
6296 : : }
6297 : :
6298 : 18225656 : return ret;
6299 : 9112828 : }
6300 : :
6301 : : /* Push internal DECL into the global namespace. Does not do the
6302 : : full overload fn handling and does not add it to the list of things
6303 : : in the namespace. */
6304 : :
6305 : : void
6306 : 3500446 : set_global_binding (tree decl)
6307 : : {
6308 : 3500446 : auto_cond_timevar tv (TV_NAME_LOOKUP);
6309 : :
6310 : 3500446 : tree *slot = find_namespace_slot (global_namespace, DECL_NAME (decl), true);
6311 : :
6312 : 3500446 : if (*slot)
6313 : : /* The user's placed something in the implementor's namespace. */
6314 : 0 : diagnose_name_conflict (decl, MAYBE_STAT_DECL (*slot));
6315 : :
6316 : : /* Force the binding, so compiler internals continue to work. */
6317 : 3500446 : *slot = decl;
6318 : 3500446 : }
6319 : :
6320 : : /* Set the context of a declaration to scope. Complain if we are not
6321 : : outside scope. */
6322 : :
6323 : : void
6324 : 93920 : set_decl_namespace (tree decl, tree scope, bool friendp)
6325 : : {
6326 : : /* Get rid of namespace aliases. */
6327 : 93920 : scope = ORIGINAL_NAMESPACE (scope);
6328 : :
6329 : : /* It is ok for friends to be qualified in parallel space. */
6330 : 93920 : if (!friendp && !is_nested_namespace (current_namespace, scope))
6331 : 6 : error ("declaration of %qD not in a namespace surrounding %qD",
6332 : : decl, scope);
6333 : 93920 : DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
6334 : :
6335 : : /* See whether this has been declared in the namespace or inline
6336 : : children. */
6337 : 93920 : tree old = NULL_TREE;
6338 : 93920 : {
6339 : 93920 : name_lookup lookup (DECL_NAME (decl),
6340 : 93920 : LOOK_want::NORMAL | LOOK_want::HIDDEN_FRIEND);
6341 : 93920 : if (!lookup.search_qualified (scope, /*usings=*/false))
6342 : : /* No old declaration at all. */
6343 : 30 : goto not_found;
6344 : 93890 : old = lookup.value;
6345 : 93920 : }
6346 : :
6347 : : /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
6348 : 93890 : if (TREE_CODE (old) == TREE_LIST)
6349 : : {
6350 : 9 : ambiguous:
6351 : 15 : auto_diagnostic_group d;
6352 : 15 : DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
6353 : 15 : error ("reference to %qD is ambiguous", decl);
6354 : 15 : print_candidates (old);
6355 : 15 : return;
6356 : : }
6357 : :
6358 : 93881 : if (!DECL_DECLARES_FUNCTION_P (decl))
6359 : : {
6360 : : /* Don't compare non-function decls with decls_match here, since
6361 : : it can't check for the correct constness at this
6362 : : point. pushdecl will find those errors later. */
6363 : :
6364 : : /* We might have found it in an inline namespace child of SCOPE. */
6365 : 2615 : if (TREE_CODE (decl) == TREE_CODE (old))
6366 : 35 : DECL_CONTEXT (decl) = DECL_CONTEXT (old);
6367 : :
6368 : 2580 : found:
6369 : : /* Writing "N::i" to declare something directly in "N" is invalid. */
6370 : 45344 : if (CP_DECL_CONTEXT (decl) == current_namespace
6371 : 45344 : && at_namespace_scope_p ())
6372 : 3 : error_at (DECL_SOURCE_LOCATION (decl),
6373 : : "explicit qualification in declaration of %qD", decl);
6374 : 45344 : return;
6375 : : }
6376 : :
6377 : : /* Since decl is a function, old should contain a function decl. */
6378 : 91266 : if (!OVL_P (old))
6379 : : {
6380 : 9 : not_found:
6381 : : /* It didn't work, go back to the explicit scope. */
6382 : 45 : DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
6383 : 45 : error ("%qD should have been declared inside %qD", decl, scope);
6384 : :
6385 : 45 : return;
6386 : : }
6387 : :
6388 : : /* We handle these in check_explicit_instantiation_namespace. */
6389 : 91257 : if (processing_explicit_instantiation)
6390 : : return;
6391 : 91175 : if (processing_template_decl || processing_specialization)
6392 : : /* We have not yet called push_template_decl to turn a
6393 : : FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
6394 : : match. But, we'll check later, when we construct the
6395 : : template. */
6396 : : return;
6397 : :
6398 : : /* Instantiations or specializations of templates may be declared as
6399 : : friends in any namespace. */
6400 : 42759 : if (friendp && DECL_USE_TEMPLATE (decl))
6401 : : return;
6402 : :
6403 : 42753 : tree found = NULL_TREE;
6404 : 42753 : bool hidden_p = false;
6405 : 42753 : bool saw_template = false;
6406 : :
6407 : 104990 : for (lkp_iterator iter (old); iter; ++iter)
6408 : : {
6409 : 62243 : if (iter.using_p ())
6410 : 0 : continue;
6411 : :
6412 : 62243 : tree ofn = *iter;
6413 : :
6414 : : /* Adjust DECL_CONTEXT first so decls_match will return true
6415 : : if DECL will match a declaration in an inline namespace. */
6416 : 62243 : DECL_CONTEXT (decl) = DECL_CONTEXT (ofn);
6417 : 62243 : if (decls_match (decl, ofn))
6418 : : {
6419 : 42741 : if (found)
6420 : : {
6421 : : /* We found more than one matching declaration. This
6422 : : can happen if we have two inline namespace children,
6423 : : each containing a suitable declaration. */
6424 : 6 : DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
6425 : 6 : goto ambiguous;
6426 : : }
6427 : 42735 : found = ofn;
6428 : 42735 : hidden_p = iter.hidden_p ();
6429 : : }
6430 : 19502 : else if (TREE_CODE (decl) == FUNCTION_DECL
6431 : 19502 : && TREE_CODE (ofn) == TEMPLATE_DECL)
6432 : 62237 : saw_template = true;
6433 : : }
6434 : :
6435 : 42747 : if (!found && friendp && saw_template)
6436 : : {
6437 : : /* "[if no non-template match is found,] each remaining function template
6438 : : is replaced with the specialization chosen by deduction from the
6439 : : friend declaration or discarded if deduction fails."
6440 : :
6441 : : So tell check_explicit_specialization to look for a match. */
6442 : 12 : SET_DECL_IMPLICIT_INSTANTIATION (decl);
6443 : 12 : DECL_TEMPLATE_INFO (decl) = build_template_info (old, NULL_TREE);
6444 : 12 : return;
6445 : : }
6446 : :
6447 : 42735 : if (found)
6448 : : {
6449 : 42729 : if (hidden_p)
6450 : : {
6451 : 3 : auto_diagnostic_group d;
6452 : 3 : pedwarn (DECL_SOURCE_LOCATION (decl), 0,
6453 : : "%qD has not been declared within %qD", decl, scope);
6454 : 3 : inform (DECL_SOURCE_LOCATION (found),
6455 : : "only here as a %<friend%>");
6456 : 3 : }
6457 : 42729 : DECL_CONTEXT (decl) = DECL_CONTEXT (found);
6458 : 42729 : goto found;
6459 : : }
6460 : :
6461 : 6 : goto not_found;
6462 : : }
6463 : :
6464 : : /* Return the namespace where the current declaration is declared. */
6465 : :
6466 : : tree
6467 : 1220116399 : current_decl_namespace (void)
6468 : : {
6469 : 1220116399 : tree result;
6470 : : /* If we have been pushed into a different namespace, use it. */
6471 : 1220116399 : if (!vec_safe_is_empty (decl_namespace_list))
6472 : 58006666 : return decl_namespace_list->last ();
6473 : :
6474 : 1162109733 : if (current_class_type)
6475 : 486184950 : result = decl_namespace_context (current_class_type);
6476 : 675924783 : else if (current_function_decl)
6477 : 245622410 : result = decl_namespace_context (current_function_decl);
6478 : : else
6479 : 430302373 : result = current_namespace;
6480 : : return result;
6481 : : }
6482 : :
6483 : : /* Process any ATTRIBUTES on a namespace definition. Returns true if
6484 : : attribute visibility is seen. */
6485 : :
6486 : : bool
6487 : 5063552 : handle_namespace_attrs (tree ns, tree attributes)
6488 : : {
6489 : 5063552 : tree d;
6490 : 5063552 : bool saw_vis = false;
6491 : :
6492 : 5063552 : if (attributes == error_mark_node)
6493 : : return false;
6494 : :
6495 : 7644698 : for (d = attributes; d; d = TREE_CHAIN (d))
6496 : : {
6497 : 2581146 : tree name = get_attribute_name (d);
6498 : 2581146 : tree args = TREE_VALUE (d);
6499 : :
6500 : 2581146 : if (is_attribute_p ("visibility", name))
6501 : : {
6502 : : /* attribute visibility is a property of the syntactic block
6503 : : rather than the namespace as a whole, so we don't touch the
6504 : : NAMESPACE_DECL at all. */
6505 : 2535929 : tree x = args ? TREE_VALUE (args) : NULL_TREE;
6506 : 2535929 : if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
6507 : : {
6508 : 0 : warning (OPT_Wattributes,
6509 : : "%qD attribute requires a single NTBS argument",
6510 : : name);
6511 : 0 : continue;
6512 : : }
6513 : :
6514 : 2535929 : if (!TREE_PUBLIC (ns))
6515 : 0 : warning (OPT_Wattributes,
6516 : : "%qD attribute is meaningless since members of the "
6517 : : "anonymous namespace get local symbols", name);
6518 : :
6519 : 2535929 : push_visibility (TREE_STRING_POINTER (x), 1);
6520 : 2535929 : saw_vis = true;
6521 : : }
6522 : 45217 : else if (is_attribute_p ("abi_tag", name))
6523 : : {
6524 : 45127 : if (!DECL_NAME (ns))
6525 : : {
6526 : 3 : warning (OPT_Wattributes, "ignoring %qD attribute on anonymous "
6527 : : "namespace", name);
6528 : 3 : continue;
6529 : : }
6530 : 45124 : if (!DECL_NAMESPACE_INLINE_P (ns))
6531 : : {
6532 : 0 : warning (OPT_Wattributes, "ignoring %qD attribute on non-inline "
6533 : : "namespace", name);
6534 : 0 : continue;
6535 : : }
6536 : 45124 : if (!args)
6537 : : {
6538 : 15 : tree dn = DECL_NAME (ns);
6539 : 15 : args = build_string (IDENTIFIER_LENGTH (dn) + 1,
6540 : 15 : IDENTIFIER_POINTER (dn));
6541 : 15 : TREE_TYPE (args) = char_array_type_node;
6542 : 15 : args = fix_string_type (args);
6543 : 15 : args = build_tree_list (NULL_TREE, args);
6544 : : }
6545 : 45124 : if (check_abi_tag_args (args, name))
6546 : 45124 : DECL_ATTRIBUTES (ns) = tree_cons (name, args,
6547 : 45124 : DECL_ATTRIBUTES (ns));
6548 : : }
6549 : 90 : else if (is_attribute_p ("deprecated", name))
6550 : : {
6551 : 69 : if (!DECL_NAME (ns))
6552 : : {
6553 : 3 : warning (OPT_Wattributes, "ignoring %qD attribute on anonymous "
6554 : : "namespace", name);
6555 : 3 : continue;
6556 : : }
6557 : 72 : if (args && TREE_CODE (TREE_VALUE (args)) != STRING_CST)
6558 : : {
6559 : 0 : error ("deprecated message is not a string");
6560 : 0 : continue;
6561 : : }
6562 : 66 : TREE_DEPRECATED (ns) = 1;
6563 : 66 : if (args)
6564 : 6 : DECL_ATTRIBUTES (ns) = tree_cons (name, args,
6565 : 6 : DECL_ATTRIBUTES (ns));
6566 : : }
6567 : 21 : else if (!attribute_ignored_p (d))
6568 : : {
6569 : 6 : warning (OPT_Wattributes, "%qD attribute directive ignored",
6570 : : name);
6571 : 6 : continue;
6572 : : }
6573 : : }
6574 : :
6575 : : return saw_vis;
6576 : : }
6577 : :
6578 : : /* Temporarily set the namespace for the current declaration. */
6579 : :
6580 : : void
6581 : 68930573 : push_decl_namespace (tree decl)
6582 : : {
6583 : 68930573 : if (TREE_CODE (decl) != NAMESPACE_DECL)
6584 : 0 : decl = decl_namespace_context (decl);
6585 : 68930573 : vec_safe_push (decl_namespace_list, ORIGINAL_NAMESPACE (decl));
6586 : 68930573 : }
6587 : :
6588 : : /* [namespace.memdef]/2 */
6589 : :
6590 : : void
6591 : 68930570 : pop_decl_namespace (void)
6592 : : {
6593 : 68930570 : decl_namespace_list->pop ();
6594 : 68930570 : }
6595 : :
6596 : : /* Process a namespace-alias declaration. */
6597 : :
6598 : : void
6599 : 106932 : do_namespace_alias (tree alias, tree name_space)
6600 : : {
6601 : 106932 : if (name_space == error_mark_node)
6602 : : return;
6603 : :
6604 : 106923 : gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
6605 : :
6606 : 106923 : name_space = ORIGINAL_NAMESPACE (name_space);
6607 : :
6608 : : /* Build the alias. */
6609 : 106923 : alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
6610 : 106923 : DECL_NAMESPACE_ALIAS (alias) = name_space;
6611 : 106923 : DECL_EXTERNAL (alias) = 1;
6612 : 106923 : DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
6613 : 106923 : set_originating_module (alias);
6614 : :
6615 : 106923 : pushdecl (alias);
6616 : :
6617 : : /* Emit debug info for namespace alias. */
6618 : 106923 : if (!building_stmt_list_p ())
6619 : 5055 : (*debug_hooks->early_global_decl) (alias);
6620 : : }
6621 : :
6622 : : /* Like pushdecl, only it places DECL in the current namespace,
6623 : : if appropriate. */
6624 : :
6625 : : tree
6626 : 44079872 : pushdecl_namespace_level (tree decl, bool hiding)
6627 : : {
6628 : 44079872 : auto_cond_timevar tv (TV_NAME_LOOKUP);
6629 : 44079872 : return do_pushdecl_with_scope (decl, NAMESPACE_LEVEL (current_namespace),
6630 : 44079872 : hiding);
6631 : 44079872 : }
6632 : :
6633 : : /* Wrapper around push_local_binding to push the bindings for
6634 : : a non-member USING_DECL with NAME and VALUE. LOOKUP, if non-null,
6635 : : is the result of name lookup during template parsing. */
6636 : :
6637 : : static void
6638 : 670100 : push_using_decl_bindings (name_lookup *lookup, tree name, tree value)
6639 : : {
6640 : 670100 : tree type = NULL_TREE;
6641 : :
6642 : 670100 : cxx_binding *binding = find_local_binding (current_binding_level, name);
6643 : 670100 : if (binding)
6644 : : {
6645 : 78 : value = binding->value;
6646 : 78 : type = binding->type;
6647 : : }
6648 : :
6649 : : /* DR 36 questions why using-decls at function scope may not be
6650 : : duplicates. Disallow it, as C++11 claimed and PR 20420
6651 : : implemented. */
6652 : 670100 : if (lookup)
6653 : 538586 : do_nonmember_using_decl (*lookup, true, true, &value, &type);
6654 : :
6655 : 670100 : if (!value)
6656 : : ;
6657 : 670100 : else if (binding && value == binding->value)
6658 : : /* Redeclaration of this USING_DECL. */;
6659 : 39 : else if (binding && binding->value && TREE_CODE (value) == OVERLOAD)
6660 : : {
6661 : : /* We already have this binding, so replace it. */
6662 : 36 : update_local_overload (IDENTIFIER_BINDING (name), value);
6663 : 36 : IDENTIFIER_BINDING (name)->value = value;
6664 : : }
6665 : : else
6666 : : /* Install the new binding. */
6667 : 670025 : push_local_binding (name, value, /*using=*/true);
6668 : :
6669 : 670100 : if (!type)
6670 : : ;
6671 : 21 : else if (binding && type == binding->type)
6672 : : ;
6673 : : else
6674 : : {
6675 : 15 : push_local_binding (name, type, /*using=*/true);
6676 : 15 : set_identifier_type_value (name, type);
6677 : : }
6678 : 670100 : }
6679 : :
6680 : : /* Overload for push_using_decl_bindings that doesn't take a name_lookup. */
6681 : :
6682 : : void
6683 : 131514 : push_using_decl_bindings (tree name, tree value)
6684 : : {
6685 : 131514 : push_using_decl_bindings (nullptr, name, value);
6686 : 131514 : }
6687 : :
6688 : : /* Process a using declaration in non-class scope. */
6689 : :
6690 : : void
6691 : 6364012 : finish_nonmember_using_decl (tree scope, tree name)
6692 : : {
6693 : 6364012 : gcc_checking_assert (current_binding_level->kind != sk_class);
6694 : :
6695 : 6364012 : if (scope == error_mark_node || name == error_mark_node)
6696 : 44 : return;
6697 : :
6698 : 6364012 : name_lookup lookup (name);
6699 : :
6700 : 6364012 : tree using_decl = lookup_using_decl (scope, lookup);
6701 : 6364012 : if (!using_decl)
6702 : 44 : return;
6703 : :
6704 : : /* Emit debug info. */
6705 : 6363968 : if (!processing_template_decl)
6706 : 11674170 : cp_emit_debug_info_for_using (lookup.value,
6707 : 5837085 : current_binding_level->this_entity);
6708 : :
6709 : 6363968 : if (current_binding_level->kind == sk_namespace)
6710 : : {
6711 : 5825382 : tree *slot = find_namespace_slot (current_namespace, name, true);
6712 : 5825382 : tree *mslot = get_fixed_binding_slot (slot, name,
6713 : : BINDING_SLOT_CURRENT, true);
6714 : 5825382 : bool failed = false;
6715 : :
6716 : 5825382 : if (mslot != slot)
6717 : : {
6718 : : /* A module vector. I presume the binding list is going to
6719 : : be sparser than the import bitmap. Hence iterate over
6720 : : the former checking for bits set in the bitmap. */
6721 : 21 : bitmap imports = get_import_bitmap ();
6722 : 21 : binding_cluster *cluster = BINDING_VECTOR_CLUSTER_BASE (*slot);
6723 : :
6724 : : /* Scan the imported bindings. */
6725 : 21 : unsigned ix = BINDING_VECTOR_NUM_CLUSTERS (*slot);
6726 : 21 : if (BINDING_VECTOR_SLOTS_PER_CLUSTER == BINDING_SLOTS_FIXED)
6727 : : {
6728 : 21 : ix--;
6729 : 21 : cluster++;
6730 : : }
6731 : :
6732 : : /* Do this in forward order, so we load modules in an order
6733 : : the user expects. */
6734 : 42 : for (; ix--; cluster++)
6735 : 63 : for (unsigned jx = 0; jx != BINDING_VECTOR_SLOTS_PER_CLUSTER; jx++)
6736 : : {
6737 : : /* Are we importing this module? */
6738 : 42 : if (unsigned base = cluster->indices[jx].base)
6739 : 21 : if (unsigned span = cluster->indices[jx].span)
6740 : 21 : do
6741 : 21 : if (bitmap_bit_p (imports, base))
6742 : 21 : goto found;
6743 : 0 : while (++base, --span);
6744 : 21 : continue;
6745 : :
6746 : 21 : found:;
6747 : : /* Is it loaded? */
6748 : 21 : if (cluster->slots[jx].is_lazy ())
6749 : : {
6750 : 0 : gcc_assert (cluster->indices[jx].span == 1);
6751 : 0 : lazy_load_binding (cluster->indices[jx].base,
6752 : : scope, name, &cluster->slots[jx]);
6753 : : }
6754 : :
6755 : 21 : tree value = cluster->slots[jx];
6756 : 21 : if (!value)
6757 : : /* Load errors could mean there's nothing here. */
6758 : 0 : continue;
6759 : :
6760 : : /* Extract what we can see from here. If there's no
6761 : : stat_hack, then everything was exported. */
6762 : 21 : tree type = NULL_TREE;
6763 : :
6764 : : /* If no stat hack, everything is visible. */
6765 : 21 : if (STAT_HACK_P (value))
6766 : : {
6767 : 9 : if (STAT_TYPE_VISIBLE_P (value))
6768 : 3 : type = STAT_TYPE (value);
6769 : 9 : value = STAT_VISIBLE (value);
6770 : : }
6771 : :
6772 : 21 : if (do_nonmember_using_decl (lookup, false, false,
6773 : : &value, &type))
6774 : : {
6775 : 0 : failed = true;
6776 : 0 : break;
6777 : : }
6778 : 21 : }
6779 : : }
6780 : :
6781 : 21 : if (!failed)
6782 : : {
6783 : : /* Now do the current slot. */
6784 : 5825382 : tree value = MAYBE_STAT_DECL (*mslot);
6785 : 5825382 : tree type = MAYBE_STAT_TYPE (*mslot);
6786 : :
6787 : 5825382 : do_nonmember_using_decl (lookup, false, true, &value, &type);
6788 : :
6789 : : // FIXME: Partition mergeableness?
6790 : 5825382 : if (STAT_HACK_P (*mslot))
6791 : : {
6792 : 0 : STAT_DECL (*mslot) = value;
6793 : 0 : STAT_TYPE (*mslot) = type;
6794 : : }
6795 : 5825382 : else if (type)
6796 : 22 : *mslot = stat_hack (value, type);
6797 : : else
6798 : 5825360 : *mslot = value;
6799 : : }
6800 : : }
6801 : : else
6802 : : {
6803 : 538586 : add_decl_expr (using_decl);
6804 : 538586 : if (DECL_DEPENDENT_P (using_decl))
6805 : 7 : lookup.value = using_decl;
6806 : 538586 : push_using_decl_bindings (&lookup, name, NULL_TREE);
6807 : : }
6808 : 6364012 : }
6809 : :
6810 : : /* Return the declarations that are members of the namespace NS. */
6811 : :
6812 : : tree
6813 : 9 : cp_namespace_decls (tree ns)
6814 : : {
6815 : 9 : return NAMESPACE_LEVEL (ns)->names;
6816 : : }
6817 : :
6818 : : /* Given a lookup that returned VAL, use FLAGS to decide if we want to
6819 : : ignore it or not. Subroutine of lookup_name_1 and lookup_type_scope. */
6820 : :
6821 : : static bool
6822 : 2883633050 : qualify_lookup (tree val, LOOK_want want)
6823 : : {
6824 : 2883633050 : if (val == NULL_TREE)
6825 : : return false;
6826 : :
6827 : 2883633050 : if (bool (want & LOOK_want::TYPE))
6828 : : {
6829 : 38313032 : tree target_val = strip_using_decl (val);
6830 : :
6831 : 38313032 : if (TREE_CODE (STRIP_TEMPLATE (target_val)) == TYPE_DECL)
6832 : : return true;
6833 : : }
6834 : :
6835 : 2845596142 : if (bool (want & LOOK_want::TYPE_NAMESPACE))
6836 : 475804 : return TREE_CODE (val) == NAMESPACE_DECL;
6837 : :
6838 : : return true;
6839 : : }
6840 : :
6841 : : /* Is there a "using namespace std;" directive within USINGS? */
6842 : :
6843 : : static bool
6844 : 5016 : using_directives_contain_std_p (vec<tree, va_gc> *usings)
6845 : : {
6846 : 5016 : if (!usings)
6847 : : return false;
6848 : :
6849 : 46 : for (unsigned ix = usings->length (); ix--;)
6850 : 31 : if ((*usings)[ix] == std_node)
6851 : : return true;
6852 : :
6853 : : return false;
6854 : : }
6855 : :
6856 : : /* Is there a "using namespace std;" directive within the current
6857 : : namespace (or its ancestors)?
6858 : : Compare with name_lookup::search_unqualified. */
6859 : :
6860 : : static bool
6861 : 1620 : has_using_namespace_std_directive_p ()
6862 : : {
6863 : 1620 : for (cp_binding_level *level = current_binding_level;
6864 : 6620 : level;
6865 : 5000 : level = level->level_chain)
6866 : 5016 : if (using_directives_contain_std_p (level->using_directives))
6867 : : return true;
6868 : :
6869 : : return false;
6870 : : }
6871 : :
6872 : : /* Subclass of deferred_diagnostic, for issuing a note when
6873 : : --param cxx-max-namespaces-for-diagnostic-help is reached.
6874 : :
6875 : : The note should be issued after the error, but before any other
6876 : : deferred diagnostics. This is handled by decorating a wrapped
6877 : : deferred_diagnostic, and emitting a note before that wrapped note is
6878 : : deleted. */
6879 : :
6880 : : class namespace_limit_reached : public deferred_diagnostic
6881 : : {
6882 : : public:
6883 : 3 : namespace_limit_reached (location_t loc, unsigned limit, tree name,
6884 : : std::unique_ptr<deferred_diagnostic> wrapped)
6885 : 3 : : deferred_diagnostic (loc),
6886 : 3 : m_limit (limit), m_name (name),
6887 : 3 : m_wrapped (std::move (wrapped))
6888 : : {
6889 : : }
6890 : :
6891 : 6 : ~namespace_limit_reached ()
6892 : 3 : {
6893 : : /* Unconditionally warn that the search was truncated. */
6894 : 3 : inform (get_location (),
6895 : : "maximum limit of %d namespaces searched for %qE",
6896 : : m_limit, m_name);
6897 : : /* m_wrapped will be implicitly deleted after this, emitting any followup
6898 : : diagnostic after the above note. */
6899 : 6 : }
6900 : :
6901 : : private:
6902 : : unsigned m_limit;
6903 : : tree m_name;
6904 : : std::unique_ptr<deferred_diagnostic> m_wrapped;
6905 : : };
6906 : :
6907 : : /* Subclass of deferred_diagnostic, for use when issuing a single suggestion.
6908 : : Emit a note showing the location of the declaration of the suggestion. */
6909 : :
6910 : : class show_candidate_location : public deferred_diagnostic
6911 : : {
6912 : : public:
6913 : 108 : show_candidate_location (location_t loc, tree candidate)
6914 : 108 : : deferred_diagnostic (loc),
6915 : 108 : m_candidate (candidate)
6916 : : {
6917 : : }
6918 : :
6919 : 216 : ~show_candidate_location ()
6920 : 108 : {
6921 : 108 : inform (location_of (m_candidate), "%qE declared here", m_candidate);
6922 : 216 : }
6923 : :
6924 : : private:
6925 : : tree m_candidate;
6926 : : };
6927 : :
6928 : : /* Subclass of deferred_diagnostic, for use when there are multiple candidates
6929 : : to be suggested by suggest_alternatives_for.
6930 : :
6931 : : Emit a series of notes showing the various suggestions. */
6932 : :
6933 : : class suggest_alternatives : public deferred_diagnostic
6934 : : {
6935 : : public:
6936 : 17 : suggest_alternatives (location_t loc, vec<tree> candidates)
6937 : 17 : : deferred_diagnostic (loc),
6938 : 17 : m_candidates (candidates)
6939 : : {
6940 : : }
6941 : :
6942 : 34 : ~suggest_alternatives ()
6943 : 17 : {
6944 : 17 : if (m_candidates.length ())
6945 : : {
6946 : 17 : inform_n (get_location (), m_candidates.length (),
6947 : : "suggested alternative:",
6948 : : "suggested alternatives:");
6949 : 108 : for (unsigned ix = 0; ix != m_candidates.length (); ix++)
6950 : : {
6951 : 37 : tree val = m_candidates[ix];
6952 : :
6953 : 37 : inform (location_of (val), " %qE", val);
6954 : : }
6955 : : }
6956 : 17 : m_candidates.release ();
6957 : 34 : }
6958 : :
6959 : : private:
6960 : : vec<tree> m_candidates;
6961 : : };
6962 : :
6963 : : /* A class for encapsulating the result of a search across
6964 : : multiple namespaces (and scoped enums within them) for an
6965 : : unrecognized name seen at a given source location. */
6966 : :
6967 : : class namespace_hints
6968 : : {
6969 : : public:
6970 : : namespace_hints (location_t loc, tree name);
6971 : :
6972 : : name_hint convert_candidates_to_name_hint ();
6973 : : name_hint maybe_decorate_with_limit (name_hint);
6974 : :
6975 : : private:
6976 : : void maybe_add_candidate_for_scoped_enum (tree scoped_enum, tree name);
6977 : :
6978 : : location_t m_loc;
6979 : : tree m_name;
6980 : : vec<tree> m_candidates;
6981 : :
6982 : : /* Value of "--param cxx-max-namespaces-for-diagnostic-help". */
6983 : : unsigned m_limit;
6984 : :
6985 : : /* Was the limit reached? */
6986 : : bool m_limited;
6987 : : };
6988 : :
6989 : : /* Constructor for namespace_hints. Search namespaces and scoped enums,
6990 : : looking for an exact match for unrecognized NAME seen at LOC. */
6991 : :
6992 : 1778 : namespace_hints::namespace_hints (location_t loc, tree name)
6993 : 1778 : : m_loc(loc), m_name (name)
6994 : : {
6995 : 1778 : auto_vec<tree> worklist;
6996 : :
6997 : 1778 : m_candidates = vNULL;
6998 : 1778 : m_limited = false;
6999 : 1778 : m_limit = param_cxx_max_namespaces_for_diagnostic_help;
7000 : :
7001 : : /* Breadth-first search of namespaces. Up to limit namespaces
7002 : : searched (limit zero == unlimited). */
7003 : 1778 : worklist.safe_push (global_namespace);
7004 : 15406 : for (unsigned ix = 0; ix != worklist.length (); ix++)
7005 : : {
7006 : 5925 : tree ns = worklist[ix];
7007 : 5925 : name_lookup lookup (name);
7008 : :
7009 : 5925 : if (lookup.search_qualified (ns, false))
7010 : 130 : m_candidates.safe_push (lookup.value);
7011 : :
7012 : 5925 : if (!m_limited)
7013 : : {
7014 : : /* Look for child namespaces. We have to do this
7015 : : indirectly because they are chained in reverse order,
7016 : : which is confusing to the user. */
7017 : 5913 : auto_vec<tree> children;
7018 : :
7019 : 5913 : for (tree decl = NAMESPACE_LEVEL (ns)->names;
7020 : 4566044 : decl; decl = TREE_CHAIN (decl))
7021 : : {
7022 : 4560131 : if (TREE_CODE (decl) == NAMESPACE_DECL
7023 : 4251 : && !DECL_NAMESPACE_ALIAS (decl)
7024 : 4564376 : && !DECL_NAMESPACE_INLINE_P (decl))
7025 : 4156 : children.safe_push (decl);
7026 : :
7027 : : /* Look for exact matches for NAME within scoped enums.
7028 : : These aren't added to the worklist, and so don't count
7029 : : against the search limit. */
7030 : 4560131 : if (TREE_CODE (decl) == TYPE_DECL)
7031 : : {
7032 : 50318 : tree type = TREE_TYPE (decl);
7033 : 50318 : if (SCOPED_ENUM_P (type))
7034 : 1302 : maybe_add_candidate_for_scoped_enum (type, name);
7035 : : }
7036 : : }
7037 : :
7038 : 15973 : while (!m_limited && !children.is_empty ())
7039 : : {
7040 : 8300 : if (worklist.length () == m_limit)
7041 : 3 : m_limited = true;
7042 : : else
7043 : 4147 : worklist.safe_push (children.pop ());
7044 : : }
7045 : 5913 : }
7046 : 5925 : }
7047 : 1778 : }
7048 : :
7049 : : /* Drop ownership of m_candidates, using it to generate a name_hint at m_loc
7050 : : for m_name, an IDENTIFIER_NODE for which name lookup failed.
7051 : :
7052 : : If m_candidates is non-empty, use it to generate a suggestion and/or
7053 : : a deferred diagnostic that lists the possible candidate(s).
7054 : : */
7055 : :
7056 : : name_hint
7057 : 1778 : namespace_hints::convert_candidates_to_name_hint ()
7058 : : {
7059 : : /* How many candidates do we have? */
7060 : :
7061 : : /* If we have just one candidate, issue a name_hint with it as a suggestion
7062 : : (so that consumers are able to suggest it within the error message and emit
7063 : : it as a fix-it hint), and with a note showing the candidate's location. */
7064 : 1778 : if (m_candidates.length () == 1)
7065 : : {
7066 : 108 : tree candidate = m_candidates[0];
7067 : : /* Clean up CANDIDATES. */
7068 : 108 : m_candidates.release ();
7069 : 108 : return name_hint (expr_to_string (candidate),
7070 : 108 : new show_candidate_location (m_loc, candidate));
7071 : : }
7072 : 1670 : else if (m_candidates.length () > 1)
7073 : : /* If we have more than one candidate, issue a name_hint without a single
7074 : : "suggestion", but with a deferred diagnostic that lists the
7075 : : various candidates. This takes ownership of m_candidates. */
7076 : 17 : return name_hint (NULL, new suggest_alternatives (m_loc, m_candidates));
7077 : :
7078 : : /* Otherwise, m_candidates ought to be empty, so no cleanup is necessary. */
7079 : 1653 : gcc_assert (m_candidates.length () == 0);
7080 : 1653 : gcc_assert (m_candidates == vNULL);
7081 : :
7082 : 1653 : return name_hint ();
7083 : : }
7084 : :
7085 : : /* If --param cxx-max-namespaces-for-diagnostic-help was reached,
7086 : : then we want to emit a note about after the error, but before
7087 : : any other deferred diagnostics.
7088 : :
7089 : : Handle this by figuring out what hint is needed, then optionally
7090 : : decorating HINT with a namespace_limit_reached wrapper. */
7091 : :
7092 : : name_hint
7093 : 1778 : namespace_hints::maybe_decorate_with_limit (name_hint hint)
7094 : : {
7095 : 1778 : if (m_limited)
7096 : 3 : return name_hint (hint.suggestion (),
7097 : : new namespace_limit_reached (m_loc, m_limit,
7098 : : m_name,
7099 : 3 : hint.take_deferred ()));
7100 : : else
7101 : 1775 : return hint;
7102 : : }
7103 : :
7104 : : /* Look inside SCOPED_ENUM for exact matches for NAME.
7105 : : If one is found, add its CONST_DECL to m_candidates. */
7106 : :
7107 : : void
7108 : 1302 : namespace_hints::maybe_add_candidate_for_scoped_enum (tree scoped_enum,
7109 : : tree name)
7110 : : {
7111 : 1302 : gcc_assert (SCOPED_ENUM_P (scoped_enum));
7112 : :
7113 : 1840 : for (tree iter = TYPE_VALUES (scoped_enum); iter; iter = TREE_CHAIN (iter))
7114 : : {
7115 : 553 : tree id = TREE_PURPOSE (iter);
7116 : 553 : if (id == name)
7117 : : {
7118 : 15 : m_candidates.safe_push (TREE_VALUE (iter));
7119 : 15 : return;
7120 : : }
7121 : : }
7122 : : }
7123 : :
7124 : : /* Generate a name_hint at LOCATION for NAME, an IDENTIFIER_NODE for which
7125 : : name lookup failed.
7126 : :
7127 : : Search through all available namespaces and any scoped enums within them
7128 : : and generate a suggestion and/or a deferred diagnostic that lists possible
7129 : : candidate(s).
7130 : :
7131 : : If no exact matches are found, and SUGGEST_MISSPELLINGS is true, then also
7132 : : look for near-matches and suggest the best near-match, if there is one.
7133 : :
7134 : : If nothing is found, then an empty name_hint is returned. */
7135 : :
7136 : : name_hint
7137 : 1724 : suggest_alternatives_for (location_t location, tree name,
7138 : : bool suggest_misspellings)
7139 : : {
7140 : : /* First, search for exact matches in other namespaces. */
7141 : 1724 : namespace_hints ns_hints (location, name);
7142 : 1724 : name_hint result = ns_hints.convert_candidates_to_name_hint ();
7143 : :
7144 : : /* Otherwise, try other approaches. */
7145 : 1724 : if (!result)
7146 : 1620 : result = suggest_alternatives_for_1 (location, name, suggest_misspellings);
7147 : :
7148 : 1724 : return ns_hints.maybe_decorate_with_limit (std::move (result));
7149 : 1724 : }
7150 : :
7151 : : /* The second half of suggest_alternatives_for, for when no exact matches
7152 : : were found in other namespaces. */
7153 : :
7154 : : static name_hint
7155 : 1620 : suggest_alternatives_for_1 (location_t location, tree name,
7156 : : bool suggest_misspellings)
7157 : : {
7158 : : /* No candidates were found in the available namespaces. */
7159 : :
7160 : : /* If there's a "using namespace std;" active, and this
7161 : : is one of the most common "std::" names, then it's probably a
7162 : : missing #include. */
7163 : 1620 : if (has_using_namespace_std_directive_p ())
7164 : : {
7165 : 16 : name_hint hint = maybe_suggest_missing_std_header (location, name);
7166 : 16 : if (hint)
7167 : 16 : return hint;
7168 : 16 : }
7169 : :
7170 : : /* Otherwise, consider misspellings. */
7171 : 1604 : if (!suggest_misspellings)
7172 : 0 : return name_hint ();
7173 : :
7174 : 1604 : return lookup_name_fuzzy (name, FUZZY_LOOKUP_NAME, location);
7175 : : }
7176 : :
7177 : : /* Generate a name_hint at LOCATION for NAME, an IDENTIFIER_NODE for which
7178 : : name lookup failed.
7179 : :
7180 : : Search through all available namespaces and generate a suggestion and/or
7181 : : a deferred diagnostic that lists possible candidate(s).
7182 : :
7183 : : This is similiar to suggest_alternatives_for, but doesn't fallback to
7184 : : the other approaches used by that function. */
7185 : :
7186 : : name_hint
7187 : 54 : suggest_alternatives_in_other_namespaces (location_t location, tree name)
7188 : : {
7189 : 54 : namespace_hints ns_hints (location, name);
7190 : :
7191 : 54 : name_hint result = ns_hints.convert_candidates_to_name_hint ();
7192 : :
7193 : 54 : return ns_hints.maybe_decorate_with_limit (std::move (result));
7194 : 54 : }
7195 : :
7196 : : /* A well-known name within the C++ standard library, returned by
7197 : : get_std_name_hint.
7198 : :
7199 : : The gperf-generated file contains the definition of the class
7200 : : "std_name_hint_lookup" with a static member function which
7201 : : returns the pointer to a structure "std_name_hint" which
7202 : : is also defined in that file. */
7203 : :
7204 : : #include "std-name-hint.h"
7205 : :
7206 : : /* Subroutine of maybe_suggest_missing_header for handling unrecognized names
7207 : : for some of the most common names within "std::".
7208 : : Given non-NULL NAME, return the std_name_hint for it, or NULL. */
7209 : :
7210 : : static const std_name_hint *
7211 : 166 : get_std_name_hint (const char *name)
7212 : : {
7213 : 166 : return std_name_hint_lookup::find(name, strlen(name));
7214 : : }
7215 : :
7216 : : /* Describe DIALECT. */
7217 : :
7218 : : const char *
7219 : 3502 : get_cxx_dialect_name (enum cxx_dialect dialect)
7220 : : {
7221 : 3502 : switch (dialect)
7222 : : {
7223 : 0 : default:
7224 : 0 : gcc_unreachable ();
7225 : : case cxx98:
7226 : : return "C++98";
7227 : 4 : case cxx11:
7228 : 4 : return "C++11";
7229 : 2 : case cxx14:
7230 : 2 : return "C++14";
7231 : 1144 : case cxx17:
7232 : 1144 : return "C++17";
7233 : 1199 : case cxx20:
7234 : 1199 : return "C++20";
7235 : 1152 : case cxx23:
7236 : 1152 : return "C++23";
7237 : 1 : case cxx26:
7238 : 1 : return "C++26";
7239 : : }
7240 : : }
7241 : :
7242 : : /* Subclass of deferred_diagnostic for use for names in the "std" namespace
7243 : : that weren't recognized, but for which we know which header it ought to be
7244 : : in.
7245 : :
7246 : : Emit a note either suggesting the header to be included, or noting that
7247 : : the current dialect is too early for the given name. */
7248 : :
7249 : : class missing_std_header : public deferred_diagnostic
7250 : : {
7251 : : public:
7252 : 148 : missing_std_header (location_t loc,
7253 : : const char *name_str,
7254 : : const std_name_hint *header_hint)
7255 : 148 : : deferred_diagnostic (loc),
7256 : 148 : m_name_str (name_str),
7257 : 148 : m_header_hint (header_hint)
7258 : : {}
7259 : 296 : ~missing_std_header ()
7260 : 148 : {
7261 : 148 : gcc_rich_location richloc (get_location ());
7262 : 148 : if (cxx_dialect >= m_header_hint->min_dialect)
7263 : : {
7264 : 139 : const char *header = m_header_hint->header;
7265 : 139 : maybe_add_include_fixit (&richloc, header, true);
7266 : 139 : inform (&richloc,
7267 : : "%<std::%s%> is defined in header %qs;"
7268 : : " this is probably fixable by adding %<#include %s%>",
7269 : : m_name_str, header, header);
7270 : : }
7271 : : else
7272 : 9 : inform (&richloc,
7273 : : "%<std::%s%> is only available from %s onwards",
7274 : : m_name_str, get_cxx_dialect_name (m_header_hint->min_dialect));
7275 : 296 : }
7276 : :
7277 : : private:
7278 : : const char *m_name_str;
7279 : : const std_name_hint *m_header_hint;
7280 : : };
7281 : :
7282 : : /* Attempt to generate a name_hint that suggests pertinent header files
7283 : : for NAME at LOCATION, for common names within the "std" namespace,
7284 : : or an empty name_hint if this isn't applicable. */
7285 : :
7286 : : static name_hint
7287 : 166 : maybe_suggest_missing_std_header (location_t location, tree name)
7288 : : {
7289 : 166 : gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
7290 : :
7291 : 166 : const char *name_str = IDENTIFIER_POINTER (name);
7292 : 166 : const std_name_hint *header_hint = get_std_name_hint (name_str);
7293 : 166 : if (!header_hint)
7294 : 18 : return name_hint ();
7295 : :
7296 : 148 : return name_hint (NULL, new missing_std_header (location, name_str,
7297 : 148 : header_hint));
7298 : : }
7299 : :
7300 : : /* Attempt to generate a name_hint that suggests a missing header file
7301 : : for NAME within SCOPE at LOCATION, or an empty name_hint if this isn't
7302 : : applicable. */
7303 : :
7304 : : name_hint
7305 : 454 : maybe_suggest_missing_header (location_t location, tree name, tree scope)
7306 : : {
7307 : 454 : if (scope == NULL_TREE)
7308 : 0 : return name_hint ();
7309 : 454 : if (TREE_CODE (scope) != NAMESPACE_DECL)
7310 : 33 : return name_hint ();
7311 : : /* We only offer suggestions for the "std" namespace. */
7312 : 421 : if (scope != std_node)
7313 : 271 : return name_hint ();
7314 : 150 : return maybe_suggest_missing_std_header (location, name);
7315 : : }
7316 : :
7317 : : /* Generate a name_hint at LOCATION for NAME, an IDENTIFIER_NODE for which name
7318 : : lookup failed within the explicitly provided SCOPE.
7319 : :
7320 : : Suggest the best meaningful candidates (if any), otherwise
7321 : : an empty name_hint is returned. */
7322 : :
7323 : : name_hint
7324 : 272 : suggest_alternative_in_explicit_scope (location_t location, tree name,
7325 : : tree scope)
7326 : : {
7327 : : /* Something went very wrong; don't suggest anything. */
7328 : 272 : if (name == error_mark_node)
7329 : 2 : return name_hint ();
7330 : :
7331 : : /* Resolve any namespace aliases. */
7332 : 270 : scope = ORIGINAL_NAMESPACE (scope);
7333 : :
7334 : 270 : name_hint hint = maybe_suggest_missing_header (location, name, scope);
7335 : 270 : if (hint)
7336 : 117 : return hint;
7337 : :
7338 : 153 : cp_binding_level *level = NAMESPACE_LEVEL (scope);
7339 : :
7340 : 153 : best_match <tree, const char *> bm (name);
7341 : 153 : consider_binding_level (name, bm, level, false, FUZZY_LOOKUP_NAME);
7342 : :
7343 : : /* See if we have a good suggesion for the user. */
7344 : 153 : const char *fuzzy_name = bm.get_best_meaningful_candidate ();
7345 : 153 : if (fuzzy_name)
7346 : 40 : return name_hint (fuzzy_name, NULL);
7347 : :
7348 : 113 : return name_hint ();
7349 : 270 : }
7350 : :
7351 : : /* Given NAME, look within SCOPED_ENUM for possible spell-correction
7352 : : candidates. */
7353 : :
7354 : : name_hint
7355 : 15 : suggest_alternative_in_scoped_enum (tree name, tree scoped_enum)
7356 : : {
7357 : 15 : gcc_assert (SCOPED_ENUM_P (scoped_enum));
7358 : :
7359 : 15 : best_match <tree, const char *> bm (name);
7360 : 48 : for (tree iter = TYPE_VALUES (scoped_enum); iter; iter = TREE_CHAIN (iter))
7361 : : {
7362 : 33 : tree id = TREE_PURPOSE (iter);
7363 : 33 : bm.consider (IDENTIFIER_POINTER (id));
7364 : : }
7365 : 15 : return name_hint (bm.get_best_meaningful_candidate (), NULL);
7366 : : }
7367 : :
7368 : : /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
7369 : : or a class TYPE).
7370 : :
7371 : : WANT as for lookup_name_1.
7372 : :
7373 : : Returns a DECL (or OVERLOAD, or BASELINK) representing the
7374 : : declaration found. If no suitable declaration can be found,
7375 : : ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
7376 : : neither a class-type nor a namespace a diagnostic is issued. */
7377 : :
7378 : : tree
7379 : 372586302 : lookup_qualified_name (tree scope, tree name, LOOK_want want, bool complain)
7380 : : {
7381 : 372586302 : tree t = NULL_TREE;
7382 : :
7383 : 372586302 : if (TREE_CODE (scope) == NAMESPACE_DECL)
7384 : : {
7385 : 275041148 : name_lookup lookup (name, want);
7386 : :
7387 : 275041148 : if (qualified_namespace_lookup (scope, &lookup))
7388 : : {
7389 : 273930923 : t = lookup.value;
7390 : :
7391 : : /* If we have a known type overload, pull it out. This can happen
7392 : : for using decls. */
7393 : 273930923 : if (TREE_CODE (t) == OVERLOAD && TREE_TYPE (t) != unknown_type_node)
7394 : 1042893 : t = OVL_FUNCTION (t);
7395 : : }
7396 : 275041148 : }
7397 : 97545154 : else if (cxx_dialect != cxx98 && TREE_CODE (scope) == ENUMERAL_TYPE)
7398 : 6440868 : t = lookup_enumerator (scope, name);
7399 : 91104286 : else if (is_class_type (scope, complain))
7400 : 90827708 : t = lookup_member (scope, name, 2, bool (want & LOOK_want::TYPE),
7401 : : tf_warning_or_error);
7402 : :
7403 : 372309670 : if (!t)
7404 : 1441127 : return error_mark_node;
7405 : : return t;
7406 : : }
7407 : :
7408 : : /* Wrapper for the above that takes a string argument. The function name is
7409 : : not at the beginning of the line to keep this wrapper out of etags. */
7410 : :
7411 : 122327 : tree lookup_qualified_name (tree t, const char *p, LOOK_want w, bool c)
7412 : : {
7413 : 122327 : return lookup_qualified_name (t, get_identifier (p), w, c);
7414 : : }
7415 : :
7416 : : /* [namespace.qual]
7417 : : Accepts the NAME to lookup and its qualifying SCOPE.
7418 : : Returns the name/type pair found into the cxx_binding *RESULT,
7419 : : or false on error. */
7420 : :
7421 : : static bool
7422 : 281292597 : qualified_namespace_lookup (tree scope, name_lookup *lookup)
7423 : : {
7424 : 281292597 : timevar_start (TV_NAME_LOOKUP);
7425 : 281292597 : query_oracle (lookup->name);
7426 : 281292597 : bool found = lookup->search_qualified (ORIGINAL_NAMESPACE (scope));
7427 : 281292597 : timevar_stop (TV_NAME_LOOKUP);
7428 : 281292597 : return found;
7429 : : }
7430 : :
7431 : : /* If DECL is suitably visible to the user, consider its name for
7432 : : spelling correction. */
7433 : :
7434 : : static void
7435 : 1788 : consider_decl (tree decl, best_match <tree, const char *> &bm,
7436 : : bool consider_impl_names)
7437 : : {
7438 : : /* Skip compiler-generated variables (e.g. __for_begin/__for_end
7439 : : within range for). */
7440 : 1788 : if (VAR_P (decl) && DECL_ARTIFICIAL (decl))
7441 : : return;
7442 : :
7443 : 1719 : tree suggestion = DECL_NAME (decl);
7444 : 1719 : if (!suggestion)
7445 : : return;
7446 : :
7447 : : /* Don't suggest names that are for anonymous aggregate types, as
7448 : : they are an implementation detail generated by the compiler. */
7449 : 1621 : if (IDENTIFIER_ANON_P (suggestion))
7450 : : return;
7451 : :
7452 : 1578 : const char *suggestion_str = IDENTIFIER_POINTER (suggestion);
7453 : :
7454 : : /* Ignore internal names with spaces in them. */
7455 : 1578 : if (strchr (suggestion_str, ' '))
7456 : : return;
7457 : :
7458 : : /* Don't suggest names that are reserved for use by the
7459 : : implementation, unless NAME began with an underscore. */
7460 : 1578 : if (!consider_impl_names
7461 : 1578 : && name_reserved_for_implementation_p (suggestion_str))
7462 : : return;
7463 : :
7464 : 1556 : bm.consider (suggestion_str);
7465 : : }
7466 : :
7467 : : /* If DECL is suitably visible to the user, add its name to VEC and
7468 : : return true. Otherwise return false. */
7469 : :
7470 : : static bool
7471 : 3051113 : maybe_add_fuzzy_decl (auto_vec<tree> &vec, tree decl)
7472 : : {
7473 : : /* Skip compiler-generated variables (e.g. __for_begin/__for_end
7474 : : within range for). */
7475 : 3051113 : if (VAR_P (decl) && DECL_ARTIFICIAL (decl))
7476 : : return false;
7477 : :
7478 : 3050380 : tree suggestion = DECL_NAME (decl);
7479 : 3050380 : if (!suggestion)
7480 : : return false;
7481 : :
7482 : : /* Don't suggest names that are for anonymous aggregate types, as
7483 : : they are an implementation detail generated by the compiler. */
7484 : 3050380 : if (IDENTIFIER_ANON_P (suggestion))
7485 : : return false;
7486 : :
7487 : 3050380 : vec.safe_push (suggestion);
7488 : :
7489 : 3050380 : return true;
7490 : : }
7491 : :
7492 : : /* Examing the namespace binding BINDING, and add at most one instance
7493 : : of the name, if it contains a visible entity of interest. Return
7494 : : true if we added something. */
7495 : :
7496 : : bool
7497 : 4676389 : maybe_add_fuzzy_binding (auto_vec<tree> &vec, tree binding,
7498 : : lookup_name_fuzzy_kind kind)
7499 : : {
7500 : 4676389 : tree value = NULL_TREE;
7501 : :
7502 : 4676389 : if (STAT_HACK_P (binding))
7503 : : {
7504 : 177 : if (!STAT_TYPE_HIDDEN_P (binding)
7505 : 177 : && STAT_TYPE (binding))
7506 : : {
7507 : 75 : if (maybe_add_fuzzy_decl (vec, STAT_TYPE (binding)))
7508 : : return true;
7509 : : }
7510 : 102 : else if (!STAT_DECL_HIDDEN_P (binding))
7511 : 75 : value = STAT_DECL (binding);
7512 : : }
7513 : : else
7514 : : value = binding;
7515 : :
7516 : 4676314 : value = ovl_skip_hidden (value);
7517 : 4676314 : if (value)
7518 : : {
7519 : 3962289 : value = OVL_FIRST (value);
7520 : 3962289 : if (kind != FUZZY_LOOKUP_TYPENAME
7521 : 3962289 : || TREE_CODE (STRIP_TEMPLATE (value)) == TYPE_DECL)
7522 : 3051038 : if (maybe_add_fuzzy_decl (vec, value))
7523 : : return true;
7524 : : }
7525 : :
7526 : : /* Nothing found. */
7527 : : return false;
7528 : : }
7529 : :
7530 : : /* Helper function for lookup_name_fuzzy.
7531 : : Traverse binding level LVL, looking for good name matches for NAME
7532 : : (and BM). */
7533 : : static void
7534 : 6048 : consider_binding_level (tree name, best_match <tree, const char *> &bm,
7535 : : cp_binding_level *lvl, bool look_within_fields,
7536 : : enum lookup_name_fuzzy_kind kind)
7537 : : {
7538 : 6048 : if (look_within_fields)
7539 : 831 : if (lvl->this_entity && TREE_CODE (lvl->this_entity) == RECORD_TYPE)
7540 : : {
7541 : 343 : tree type = lvl->this_entity;
7542 : 343 : bool want_type_p = (kind == FUZZY_LOOKUP_TYPENAME);
7543 : 343 : tree best_matching_field
7544 : 343 : = lookup_member_fuzzy (type, name, want_type_p);
7545 : 343 : if (best_matching_field)
7546 : 9 : bm.consider (IDENTIFIER_POINTER (best_matching_field));
7547 : : }
7548 : :
7549 : : /* Only suggest names reserved for the implementation if NAME begins
7550 : : with an underscore. */
7551 : 6048 : bool consider_implementation_names = (IDENTIFIER_POINTER (name)[0] == '_');
7552 : :
7553 : 6048 : if (lvl->kind != sk_namespace)
7554 : 5856 : for (tree t = lvl-> |
