1/* Declarations 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
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 3, or (at your option)
10any later version.
11
12GCC is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21#ifndef GCC_CP_NAME_LOOKUP_H
22#define GCC_CP_NAME_LOOKUP_H
23
24#include "c-family/c-common.h"
25
26
27/* The datatype used to implement C++ scope. */
28struct cp_binding_level;
29
30/* Nonzero if this binding is for a local scope, as opposed to a class
31 or namespace scope. */
32#define LOCAL_BINDING_P(NODE) ((NODE)->is_local)
33
34/* True if NODE->value is from a base class of the class which is
35 currently being defined. */
36#define INHERITED_VALUE_BINDING_P(NODE) ((NODE)->value_is_inherited)
37
38/* The IMPLICIT_TYPEDEF is hidden from ordinary name lookup (it was
39 injected via a local class's friend decl). The typdef may be in the
40 VALUE or the TYPE slot. We do not get the situation where the
41 value and type slots are both filled and both hidden. */
42#define HIDDEN_TYPE_BINDING_P(NODE) ((NODE)->type_is_hidden)
43
44/* Datatype that represents binding established by a declaration between
45 a name and a C++ entity. */
46struct GTY(()) cxx_binding {
47 /* Link to chain together various bindings for this name. */
48 cxx_binding *previous;
49 /* The non-type entity this name is bound to. */
50 tree value;
51 /* The type entity this name is bound to. */
52 tree type;
53 /* The scope at which this binding was made. */
54 cp_binding_level *scope;
55
56 bool value_is_inherited : 1;
57 bool is_local : 1;
58 bool type_is_hidden : 1;
59};
60
61/* Datatype used to temporarily save C++ bindings (for implicit
62 instantiations purposes and like). Implemented in decl.cc. */
63struct GTY(()) cxx_saved_binding {
64 /* The name of the current binding. */
65 tree identifier;
66 /* The binding we're saving. */
67 cxx_binding *binding;
68 tree real_type_value;
69};
70
71/* To support lazy module loading, we squirrel away a section number
72 (and a couple of flags) in the binding slot of unloaded bindings.
73 We rely on pointers being aligned and setting the bottom bit to
74 mark a lazy value. GTY doesn't like an array of union, so we have
75 a containing struct. */
76
77struct GTY(()) binding_slot {
78 union GTY((desc ("%1.is_lazy ()"))) binding_slot_lazy {
79 tree GTY((tag ("false"))) binding;
80 } u;
81
82 operator tree & ()
83 {
84 gcc_checking_assert (!is_lazy ());
85 return u.binding;
86 }
87 binding_slot &operator= (tree t)
88 {
89 u.binding = t;
90 return *this;
91 }
92 bool is_lazy () const
93 {
94 return bool (uintptr_t (u.binding) & 1);
95 }
96 void set_lazy (unsigned snum)
97 {
98 gcc_checking_assert (!u.binding);
99 u.binding = tree (uintptr_t ((snum << 1) | 1));
100 }
101 void or_lazy (unsigned snum)
102 {
103 gcc_checking_assert (is_lazy ());
104 u.binding = tree (uintptr_t (u.binding) | (snum << 1));
105 }
106 unsigned get_lazy () const
107 {
108 gcc_checking_assert (is_lazy ());
109 return unsigned (uintptr_t (u.binding) >> 1);
110 }
111};
112
113/* Bindings for modules are held in a sparse array. There is always a
114 current TU slot, others are allocated as needed. By construction
115 of the importing mechanism we only ever need to append to the
116 array. Rather than have straight index/slot tuples, we bunch them
117 up for greater packing.
118
119 The cluster representation packs well on a 64-bit system. */
120
121#define BINDING_VECTOR_SLOTS_PER_CLUSTER 2
122struct binding_index {
123 unsigned short base;
124 unsigned short span;
125};
126
127struct GTY(()) binding_cluster
128{
129 binding_index GTY((skip)) indices[BINDING_VECTOR_SLOTS_PER_CLUSTER];
130 binding_slot slots[BINDING_VECTOR_SLOTS_PER_CLUSTER];
131};
132
133/* These two fields overlay lang flags. So don't use those. */
134#define BINDING_VECTOR_ALLOC_CLUSTERS(NODE) \
135 (BINDING_VECTOR_CHECK (NODE)->base.u.dependence_info.clique)
136#define BINDING_VECTOR_NUM_CLUSTERS(NODE) \
137 (BINDING_VECTOR_CHECK (NODE)->base.u.dependence_info.base)
138#define BINDING_VECTOR_CLUSTER_BASE(NODE) \
139 (((tree_binding_vec *)BINDING_VECTOR_CHECK (NODE))->vec)
140#define BINDING_VECTOR_CLUSTER_LAST(NODE) \
141 (&BINDING_VECTOR_CLUSTER (NODE, BINDING_VECTOR_NUM_CLUSTERS (NODE) - 1))
142#define BINDING_VECTOR_CLUSTER(NODE,IX) \
143 (((tree_binding_vec *)BINDING_VECTOR_CHECK (NODE))->vec[IX])
144
145struct GTY(()) tree_binding_vec {
146 struct tree_base base;
147 tree name;
148 binding_cluster GTY((length ("%h.base.u.dependence_info.base"))) vec[1];
149};
150
151/* The name of a module vector. */
152#define BINDING_VECTOR_NAME(NODE) \
153 (((tree_binding_vec *)BINDING_VECTOR_CHECK (NODE))->name)
154
155/* tree_binding_vec does uses base.u.dependence_info.base field for
156 length. It does not have lang_flag etc available! */
157
158/* These two flags note if a module-vector contains deduplicated
159 bindings (i.e. multiple declarations in different imports). */
160/* This binding contains duplicate references to a global module
161 entity. */
162#define BINDING_VECTOR_GLOBAL_DUPS_P(NODE) \
163 (BINDING_VECTOR_CHECK (NODE)->base.static_flag)
164/* This binding contains duplicate references to a partioned module
165 entity. */
166#define BINDING_VECTOR_PARTITION_DUPS_P(NODE) \
167 (BINDING_VECTOR_CHECK (NODE)->base.volatile_flag)
168
169/* These two flags indicate the provenence of the bindings on this
170 particular vector slot. We can of course determine this from slot
171 number, but that's a relatively expensive lookup. This avoids
172 that when iterating. */
173/* This slot is part of the global module (a header unit). */
174#define MODULE_BINDING_GLOBAL_P(NODE) \
175 (OVERLOAD_CHECK (NODE)->base.static_flag)
176/* This slot is part of the current module (a partition or primary). */
177#define MODULE_BINDING_PARTITION_P(NODE) \
178 (OVERLOAD_CHECK (NODE)->base.volatile_flag)
179
180extern void set_identifier_type_value (tree, tree);
181extern void push_binding (tree, tree, cp_binding_level*);
182extern void pop_local_binding (tree, tree);
183extern void pop_bindings_and_leave_scope (void);
184extern tree constructor_name (tree);
185extern bool constructor_name_p (tree, tree);
186
187/* The kinds of scopes we recognize. */
188enum scope_kind {
189 sk_block = 0, /* An ordinary block scope. This enumerator must
190 have the value zero because "cp_binding_level"
191 is initialized by using "memset" to set the
192 contents to zero, and the default scope kind
193 is "sk_block". */
194 sk_cleanup, /* A scope for (pseudo-)scope for cleanup. It is
195 pseudo in that it is transparent to name lookup
196 activities. */
197 sk_try, /* A try-block. */
198 sk_catch, /* A catch-block. */
199 sk_for, /* The scope of the variable declared in a
200 init-statement. */
201 sk_cond, /* The scope of the variable declared in the condition
202 of an if or switch statement. */
203 sk_stmt_expr, /* GNU statement expression block. */
204 sk_function_parms, /* The scope containing function parameters. */
205 sk_class, /* The scope containing the members of a class. */
206 sk_scoped_enum, /* The scope containing the enumerators of a C++11
207 scoped enumeration. */
208 sk_namespace, /* The scope containing the members of a
209 namespace, including the global scope. */
210 sk_template_parms, /* A scope for template parameters. */
211 sk_template_spec, /* Like sk_template_parms, but for an explicit
212 specialization. Since, by definition, an
213 explicit specialization is introduced by
214 "template <>", this scope is always empty. */
215 sk_transaction, /* A synchronized or atomic statement. */
216 sk_omp, /* An OpenMP structured block. */
217 sk_count /* Number of scope_kind enumerations. */
218};
219
220struct GTY(()) cp_class_binding {
221 cxx_binding *base;
222 /* The bound name. */
223 tree identifier;
224};
225
226/* For each binding contour we allocate a binding_level structure
227 which records the names defined in that contour.
228 Contours include:
229 0) the global one
230 1) one for each function definition,
231 where internal declarations of the parameters appear.
232 2) one for each compound statement,
233 to record its declarations.
234
235 The current meaning of a name can be found by searching the levels
236 from the current one out to the global one.
237
238 Off to the side, may be the class_binding_level. This exists only
239 to catch class-local declarations. It is otherwise nonexistent.
240
241 Also there may be binding levels that catch cleanups that must be
242 run when exceptions occur. Thus, to see whether a name is bound in
243 the current scope, it is not enough to look in the
244 CURRENT_BINDING_LEVEL. You should use lookup_name_current_level
245 instead. */
246
247struct GTY(()) cp_binding_level {
248 /* A chain of _DECL nodes for all variables, constants, functions,
249 and typedef types. These are in the reverse of the order
250 supplied. There may be OVERLOADs on this list, too, but they
251 are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD. */
252 tree names;
253
254 /* Using directives. */
255 vec<tree, va_gc> *using_directives;
256
257 /* For the binding level corresponding to a class, the entities
258 declared in the class or its base classes. */
259 vec<cp_class_binding, va_gc> *class_shadowed;
260
261 /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
262 is used for all binding levels. The TREE_PURPOSE is the name of
263 the entity, the TREE_TYPE is the associated type. In addition
264 the TREE_VALUE is the IDENTIFIER_TYPE_VALUE before we entered
265 the class. */
266 tree type_shadowed;
267
268 /* For each level (except not the global one),
269 a chain of BLOCK nodes for all the levels
270 that were entered and exited one level down. */
271 tree blocks;
272
273 /* The entity (namespace, class, function) the scope of which this
274 binding contour corresponds to. Otherwise NULL. */
275 tree this_entity;
276
277 /* The binding level which this one is contained in (inherits from). */
278 cp_binding_level *level_chain;
279
280 /* STATEMENT_LIST for statements in this binding contour.
281 Only used at present for SK_CLEANUP temporary bindings. */
282 tree statement_list;
283
284 /* Binding depth at which this level began. */
285 int binding_depth;
286
287 /* The kind of scope that this object represents. However, a
288 SK_TEMPLATE_SPEC scope is represented with KIND set to
289 SK_TEMPLATE_PARMS and EXPLICIT_SPEC_P set to true. */
290 ENUM_BITFIELD (scope_kind) kind : 4;
291
292 /* True if this scope is an SK_TEMPLATE_SPEC scope. This field is
293 only valid if KIND == SK_TEMPLATE_PARMS. */
294 BOOL_BITFIELD explicit_spec_p : 1;
295
296 /* True means make a BLOCK for this level regardless of all else. */
297 unsigned keep : 1;
298
299 /* Nonzero if this level can safely have additional
300 cleanup-needing variables added to it. */
301 unsigned more_cleanups_ok : 1;
302 unsigned have_cleanups : 1;
303
304 /* Transient state set if this scope is of sk_class kind
305 and is in the process of defining 'this_entity'. Reset
306 on leaving the class definition to allow for the scope
307 to be subsequently re-used as a non-defining scope for
308 'this_entity'. */
309 unsigned defining_class_p : 1;
310
311 /* True for SK_FUNCTION_PARMS of a requires-expression. */
312 unsigned requires_expression : 1;
313
314 /* True for artificial blocks which should be ignored when finding
315 parent scope. */
316 unsigned artificial : 1;
317
318 /* 21 bits left to fill a 32-bit word. */
319};
320
321/* The binding level currently in effect. */
322
323#define current_binding_level \
324 (*(cfun && cp_function_chain && cp_function_chain->bindings \
325 ? &cp_function_chain->bindings \
326 : &scope_chain->bindings))
327
328/* The binding level of the current class, if any. */
329
330#define class_binding_level scope_chain->class_bindings
331
332/* True if SCOPE designates the global scope binding contour. */
333#define global_scope_p(SCOPE) \
334 ((SCOPE) == NAMESPACE_LEVEL (global_namespace))
335
336extern cp_binding_level *leave_scope (void);
337extern bool kept_level_p (void);
338extern bool global_bindings_p (void);
339extern bool toplevel_bindings_p (void);
340extern bool namespace_bindings_p (void);
341extern bool local_bindings_p (void);
342extern bool template_parm_scope_p (void);
343extern scope_kind innermost_scope_kind (void);
344extern cp_binding_level *begin_scope (scope_kind, tree);
345extern void print_binding_stack (void);
346extern void pop_everything (void);
347extern void keep_next_level (bool);
348extern bool is_ancestor (tree ancestor, tree descendant);
349extern bool is_nested_namespace (tree parent, tree descendant,
350 bool inline_only = false);
351extern tree push_scope (tree);
352extern void pop_scope (tree);
353extern tree push_inner_scope (tree);
354extern void pop_inner_scope (tree, tree);
355extern void push_binding_level (cp_binding_level *);
356
357extern bool handle_namespace_attrs (tree, tree);
358extern void pushlevel_class (void);
359extern void poplevel_class (void);
360
361/* What kind of scopes name lookup looks in. An enum class so we
362 don't accidentally mix integers. */
363enum class LOOK_where
364{
365 BLOCK = 1 << 0, /* Consider block scopes. */
366 CLASS = 1 << 1, /* Consider class scopes. */
367 NAMESPACE = 1 << 2, /* Consider namespace scopes. */
368
369 ALL = BLOCK | CLASS | NAMESPACE,
370 BLOCK_NAMESPACE = BLOCK | NAMESPACE,
371 CLASS_NAMESPACE = CLASS | NAMESPACE,
372};
373constexpr LOOK_where operator| (LOOK_where a, LOOK_where b)
374{
375 return LOOK_where (unsigned (a) | unsigned (b));
376}
377constexpr LOOK_where operator& (LOOK_where a, LOOK_where b)
378{
379 return LOOK_where (unsigned (a) & unsigned (b));
380}
381
382enum class LOOK_want
383{
384 NORMAL = 0, /* Normal lookup -- non-types can hide implicit types. */
385 TYPE = 1 << 1, /* We only want TYPE_DECLS. */
386 NAMESPACE = 1 << 2, /* We only want NAMESPACE_DECLS. */
387
388 HIDDEN_FRIEND = 1 << 3, /* See hidden friends. */
389 HIDDEN_LAMBDA = 1 << 4, /* See lambda-ignored entities. */
390
391 TYPE_NAMESPACE = TYPE | NAMESPACE, /* Either NAMESPACE or TYPE. */
392};
393constexpr LOOK_want operator| (LOOK_want a, LOOK_want b)
394{
395 return LOOK_want (unsigned (a) | unsigned (b));
396}
397constexpr LOOK_want operator& (LOOK_want a, LOOK_want b)
398{
399 return LOOK_want (unsigned (a) & unsigned (b));
400}
401
402extern tree lookup_name (tree, LOOK_where, LOOK_want = LOOK_want::NORMAL);
403/* Also declared in c-family/c-common.h. */
404extern tree lookup_name (tree name);
405inline tree lookup_name (tree name, LOOK_want want)
406{
407 return lookup_name (name, LOOK_where::ALL, want);
408}
409
410enum class TAG_how
411{
412 CURRENT_ONLY = 0, // Look and insert only in current scope
413
414 GLOBAL = 1, // Unqualified lookup, innermost-non-class insertion
415
416 INNERMOST_NON_CLASS = 2, // Look and insert only into
417 // innermost-non-class
418
419 HIDDEN_FRIEND = 3, // As INNERMOST_NON_CLASS, but hide it
420};
421
422extern tree lookup_elaborated_type (tree, TAG_how);
423extern tree get_namespace_binding (tree ns, tree id);
424extern void set_global_binding (tree decl);
425inline tree get_global_binding (tree id)
426{
427 return get_namespace_binding (NULL_TREE, id);
428}
429extern tree lookup_qualified_name (tree scope, tree name,
430 LOOK_want = LOOK_want::NORMAL,
431 bool = true);
432extern tree lookup_qualified_name (tree scope, const char *name,
433 LOOK_want = LOOK_want::NORMAL,
434 bool = true);
435extern bool pushdecl_class_level (tree);
436extern tree pushdecl_namespace_level (tree, bool hiding = false);
437extern bool push_class_level_binding (tree, tree);
438extern tree get_local_decls ();
439extern int function_parm_depth (void);
440extern tree cp_namespace_decls (tree);
441extern void set_decl_namespace (tree, tree, bool);
442extern void push_decl_namespace (tree);
443extern void pop_decl_namespace (void);
444extern void do_namespace_alias (tree, tree);
445extern tree do_class_using_decl (tree, tree);
446extern tree lookup_arg_dependent (tree, tree, vec<tree, va_gc> *);
447extern tree search_anon_aggr (tree, tree, bool = false);
448extern tree get_class_binding_direct (tree, tree, bool want_type = false);
449extern tree get_class_binding (tree, tree, bool want_type = false);
450extern tree *find_member_slot (tree klass, tree name);
451extern tree *add_member_slot (tree klass, tree name);
452extern void resort_type_member_vec (void *, void *,
453 gt_pointer_operator, void *);
454extern vec<tree, va_gc> *set_class_bindings (tree, int extra = 0);
455extern void insert_late_enum_def_bindings (tree, tree);
456extern tree innermost_non_namespace_value (tree);
457extern bool decl_in_scope_p (tree);
458extern cxx_binding *outer_binding (tree, cxx_binding *, bool);
459extern void cp_emit_debug_info_for_using (tree, tree);
460
461extern void finish_nonmember_using_decl (tree scope, tree name);
462extern void finish_using_directive (tree target, tree attribs);
463void push_local_extern_decl_alias (tree decl);
464extern tree pushdecl (tree, bool hiding = false);
465extern tree pushdecl_outermost_localscope (tree);
466extern tree pushdecl_top_level (tree);
467extern tree pushdecl_top_level_and_finish (tree, tree);
468extern tree pushtag (tree, tree, TAG_how = TAG_how::CURRENT_ONLY);
469extern int push_namespace (tree, bool make_inline = false);
470extern void pop_namespace (void);
471extern void push_nested_namespace (tree);
472extern void pop_nested_namespace (tree);
473extern void push_to_top_level (void);
474extern void pop_from_top_level (void);
475extern bool maybe_push_to_top_level (tree);
476extern void maybe_pop_from_top_level (bool);
477extern void push_using_decl_bindings (tree, tree);
478
479/* Lower level interface for modules. */
480extern tree *mergeable_namespace_slots (tree ns, tree name, bool is_attached,
481 tree *mvec);
482extern void add_mergeable_namespace_entity (tree *slot, tree decl);
483extern tree lookup_class_binding (tree ctx, tree name);
484extern bool import_module_binding (tree ctx, tree name, unsigned mod,
485 unsigned snum);
486extern bool set_module_binding (tree ctx, tree name, unsigned mod,
487 int mod_glob_flag,
488 tree value, tree type, tree visible);
489extern void add_module_namespace_decl (tree ns, tree decl);
490
491enum WMB_Flags
492{
493 WMB_None = 0,
494 WMB_Dups = 1 << 0,
495 WMB_Export = 1 << 1,
496 WMB_Using = 1 << 2,
497 WMB_Hidden = 1 << 3,
498};
499
500extern unsigned walk_module_binding (tree binding, bitmap partitions,
501 bool (*)(tree decl, WMB_Flags, void *data),
502 void *data);
503extern tree add_imported_namespace (tree ctx, tree name, location_t,
504 unsigned module,
505 bool inline_p, bool visible_p);
506extern const char *get_cxx_dialect_name (enum cxx_dialect dialect);
507
508#endif /* GCC_CP_NAME_LOOKUP_H */
509

Provided by KDAB

Privacy Policy
Learn to use CMake with our Intro Training
Find out more

source code of gcc/cp/name-lookup.h