|
145
|
1 /* Declarations for -*- C++ -*- name lookup routines.
|
|
|
2 Copyright (C) 2003-2020 Free Software Foundation, Inc.
|
|
111
|
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 #ifndef GCC_CP_NAME_LOOKUP_H
|
|
|
22 #define GCC_CP_NAME_LOOKUP_H
|
|
|
23
|
|
|
24 #include "c-family/c-common.h"
|
|
|
25
|
|
|
26 /* The type of dictionary used to map names to types declared at
|
|
|
27 a given scope. */
|
|
|
28 typedef struct binding_table_s *binding_table;
|
|
|
29 typedef struct binding_entry_s *binding_entry;
|
|
|
30
|
|
|
31 /* The type of a routine repeatedly called by binding_table_foreach. */
|
|
|
32 typedef void (*bt_foreach_proc) (binding_entry, void *);
|
|
|
33
|
|
|
34 struct GTY(()) binding_entry_s {
|
|
|
35 binding_entry chain;
|
|
|
36 tree name;
|
|
|
37 tree type;
|
|
|
38 };
|
|
|
39
|
|
|
40 /* These macros indicate the initial chains count for binding_table. */
|
|
|
41 #define SCOPE_DEFAULT_HT_SIZE (1 << 3)
|
|
|
42 #define CLASS_SCOPE_HT_SIZE (1 << 3)
|
|
|
43 #define NAMESPACE_ORDINARY_HT_SIZE (1 << 5)
|
|
|
44 #define NAMESPACE_STD_HT_SIZE (1 << 8)
|
|
|
45 #define GLOBAL_SCOPE_HT_SIZE (1 << 8)
|
|
|
46
|
|
|
47 extern void binding_table_foreach (binding_table, bt_foreach_proc, void *);
|
|
|
48 extern binding_entry binding_table_find (binding_table, tree);
|
|
|
49
|
|
|
50 /* Datatype that represents binding established by a declaration between
|
|
|
51 a name and a C++ entity. */
|
|
|
52 typedef struct cxx_binding cxx_binding;
|
|
|
53
|
|
|
54 /* The datatype used to implement C++ scope. */
|
|
|
55 typedef struct cp_binding_level cp_binding_level;
|
|
|
56
|
|
|
57 /* Nonzero if this binding is for a local scope, as opposed to a class
|
|
|
58 or namespace scope. */
|
|
|
59 #define LOCAL_BINDING_P(NODE) ((NODE)->is_local)
|
|
|
60
|
|
|
61 /* True if NODE->value is from a base class of the class which is
|
|
|
62 currently being defined. */
|
|
|
63 #define INHERITED_VALUE_BINDING_P(NODE) ((NODE)->value_is_inherited)
|
|
|
64
|
|
|
65 struct GTY(()) cxx_binding {
|
|
|
66 /* Link to chain together various bindings for this name. */
|
|
|
67 cxx_binding *previous;
|
|
|
68 /* The non-type entity this name is bound to. */
|
|
|
69 tree value;
|
|
|
70 /* The type entity this name is bound to. */
|
|
|
71 tree type;
|
|
|
72 /* The scope at which this binding was made. */
|
|
|
73 cp_binding_level *scope;
|
|
|
74 unsigned value_is_inherited : 1;
|
|
|
75 unsigned is_local : 1;
|
|
|
76 };
|
|
|
77
|
|
|
78 /* Datatype used to temporarily save C++ bindings (for implicit
|
|
|
79 instantiations purposes and like). Implemented in decl.c. */
|
|
|
80 struct GTY(()) cxx_saved_binding {
|
|
|
81 /* The name of the current binding. */
|
|
|
82 tree identifier;
|
|
|
83 /* The binding we're saving. */
|
|
|
84 cxx_binding *binding;
|
|
|
85 tree real_type_value;
|
|
|
86 };
|
|
|
87
|
|
|
88
|
|
|
89 extern tree identifier_type_value (tree);
|
|
|
90 extern void set_identifier_type_value (tree, tree);
|
|
|
91 extern void push_binding (tree, tree, cp_binding_level*);
|
|
|
92 extern void pop_local_binding (tree, tree);
|
|
|
93 extern void pop_bindings_and_leave_scope (void);
|
|
|
94 extern tree constructor_name (tree);
|
|
|
95 extern bool constructor_name_p (tree, tree);
|
|
|
96
|
|
|
97 /* The kinds of scopes we recognize. */
|
|
|
98 enum scope_kind {
|
|
|
99 sk_block = 0, /* An ordinary block scope. This enumerator must
|
|
|
100 have the value zero because "cp_binding_level"
|
|
|
101 is initialized by using "memset" to set the
|
|
|
102 contents to zero, and the default scope kind
|
|
|
103 is "sk_block". */
|
|
|
104 sk_cleanup, /* A scope for (pseudo-)scope for cleanup. It is
|
|
|
105 pseudo in that it is transparent to name lookup
|
|
|
106 activities. */
|
|
|
107 sk_try, /* A try-block. */
|
|
|
108 sk_catch, /* A catch-block. */
|
|
|
109 sk_for, /* The scope of the variable declared in a
|
|
|
110 init-statement. */
|
|
|
111 sk_cond, /* The scope of the variable declared in the condition
|
|
|
112 of an if or switch statement. */
|
|
|
113 sk_function_parms, /* The scope containing function parameters. */
|
|
|
114 sk_class, /* The scope containing the members of a class. */
|
|
131
|
115 sk_scoped_enum, /* The scope containing the enumerators of a C++11
|
|
111
|
116 scoped enumeration. */
|
|
|
117 sk_namespace, /* The scope containing the members of a
|
|
|
118 namespace, including the global scope. */
|
|
|
119 sk_template_parms, /* A scope for template parameters. */
|
|
|
120 sk_template_spec, /* Like sk_template_parms, but for an explicit
|
|
|
121 specialization. Since, by definition, an
|
|
|
122 explicit specialization is introduced by
|
|
|
123 "template <>", this scope is always empty. */
|
|
|
124 sk_transaction, /* A synchronized or atomic statement. */
|
|
|
125 sk_omp /* An OpenMP structured block. */
|
|
|
126 };
|
|
|
127
|
|
|
128 /* The scope where the class/struct/union/enum tag applies. */
|
|
|
129 enum tag_scope {
|
|
|
130 ts_current = 0, /* Current scope only. This is for the
|
|
|
131 class-key identifier;
|
|
|
132 case mentioned in [basic.lookup.elab]/2,
|
|
|
133 or the class/enum definition
|
|
|
134 class-key identifier { ... }; */
|
|
|
135 ts_global = 1, /* All scopes. This is the 3.4.1
|
|
|
136 [basic.lookup.unqual] lookup mentioned
|
|
|
137 in [basic.lookup.elab]/2. */
|
|
|
138 ts_within_enclosing_non_class = 2, /* Search within enclosing non-class
|
|
|
139 only, for friend class lookup
|
|
|
140 according to [namespace.memdef]/3
|
|
|
141 and [class.friend]/9. */
|
|
|
142 ts_lambda = 3 /* Declaring a lambda closure. */
|
|
|
143 };
|
|
|
144
|
|
|
145 struct GTY(()) cp_class_binding {
|
|
|
146 cxx_binding *base;
|
|
|
147 /* The bound name. */
|
|
|
148 tree identifier;
|
|
|
149 };
|
|
|
150
|
|
|
151 /* For each binding contour we allocate a binding_level structure
|
|
|
152 which records the names defined in that contour.
|
|
|
153 Contours include:
|
|
|
154 0) the global one
|
|
|
155 1) one for each function definition,
|
|
|
156 where internal declarations of the parameters appear.
|
|
|
157 2) one for each compound statement,
|
|
|
158 to record its declarations.
|
|
|
159
|
|
|
160 The current meaning of a name can be found by searching the levels
|
|
|
161 from the current one out to the global one.
|
|
|
162
|
|
|
163 Off to the side, may be the class_binding_level. This exists only
|
|
|
164 to catch class-local declarations. It is otherwise nonexistent.
|
|
|
165
|
|
|
166 Also there may be binding levels that catch cleanups that must be
|
|
|
167 run when exceptions occur. Thus, to see whether a name is bound in
|
|
|
168 the current scope, it is not enough to look in the
|
|
|
169 CURRENT_BINDING_LEVEL. You should use lookup_name_current_level
|
|
|
170 instead. */
|
|
|
171
|
|
|
172 struct GTY(()) cp_binding_level {
|
|
|
173 /* A chain of _DECL nodes for all variables, constants, functions,
|
|
|
174 and typedef types. These are in the reverse of the order
|
|
|
175 supplied. There may be OVERLOADs on this list, too, but they
|
|
|
176 are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD. */
|
|
|
177 tree names;
|
|
|
178
|
|
|
179 /* Using directives. */
|
|
|
180 vec<tree, va_gc> *using_directives;
|
|
|
181
|
|
|
182 /* For the binding level corresponding to a class, the entities
|
|
|
183 declared in the class or its base classes. */
|
|
|
184 vec<cp_class_binding, va_gc> *class_shadowed;
|
|
|
185
|
|
|
186 /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
|
|
|
187 is used for all binding levels. The TREE_PURPOSE is the name of
|
|
|
188 the entity, the TREE_TYPE is the associated type. In addition
|
|
|
189 the TREE_VALUE is the IDENTIFIER_TYPE_VALUE before we entered
|
|
|
190 the class. */
|
|
|
191 tree type_shadowed;
|
|
|
192
|
|
|
193 /* For each level (except not the global one),
|
|
|
194 a chain of BLOCK nodes for all the levels
|
|
|
195 that were entered and exited one level down. */
|
|
|
196 tree blocks;
|
|
|
197
|
|
|
198 /* The entity (namespace, class, function) the scope of which this
|
|
|
199 binding contour corresponds to. Otherwise NULL. */
|
|
|
200 tree this_entity;
|
|
|
201
|
|
|
202 /* The binding level which this one is contained in (inherits from). */
|
|
|
203 cp_binding_level *level_chain;
|
|
|
204
|
|
|
205 /* STATEMENT_LIST for statements in this binding contour.
|
|
|
206 Only used at present for SK_CLEANUP temporary bindings. */
|
|
|
207 tree statement_list;
|
|
|
208
|
|
|
209 /* Binding depth at which this level began. */
|
|
|
210 int binding_depth;
|
|
|
211
|
|
|
212 /* The kind of scope that this object represents. However, a
|
|
|
213 SK_TEMPLATE_SPEC scope is represented with KIND set to
|
|
|
214 SK_TEMPLATE_PARMS and EXPLICIT_SPEC_P set to true. */
|
|
|
215 ENUM_BITFIELD (scope_kind) kind : 4;
|
|
|
216
|
|
|
217 /* True if this scope is an SK_TEMPLATE_SPEC scope. This field is
|
|
|
218 only valid if KIND == SK_TEMPLATE_PARMS. */
|
|
|
219 BOOL_BITFIELD explicit_spec_p : 1;
|
|
|
220
|
|
|
221 /* true means make a BLOCK for this level regardless of all else. */
|
|
|
222 unsigned keep : 1;
|
|
|
223
|
|
|
224 /* Nonzero if this level can safely have additional
|
|
|
225 cleanup-needing variables added to it. */
|
|
|
226 unsigned more_cleanups_ok : 1;
|
|
|
227 unsigned have_cleanups : 1;
|
|
|
228
|
|
|
229 /* Transient state set if this scope is of sk_class kind
|
|
|
230 and is in the process of defining 'this_entity'. Reset
|
|
|
231 on leaving the class definition to allow for the scope
|
|
|
232 to be subsequently re-used as a non-defining scope for
|
|
|
233 'this_entity'. */
|
|
|
234 unsigned defining_class_p : 1;
|
|
|
235
|
|
145
|
236 /* true for SK_FUNCTION_PARMS of immediate functions. */
|
|
|
237 unsigned immediate_fn_ctx_p : 1;
|
|
|
238
|
|
|
239 /* 22 bits left to fill a 32-bit word. */
|
|
111
|
240 };
|
|
|
241
|
|
|
242 /* The binding level currently in effect. */
|
|
|
243
|
|
|
244 #define current_binding_level \
|
|
|
245 (*(cfun && cp_function_chain && cp_function_chain->bindings \
|
|
|
246 ? &cp_function_chain->bindings \
|
|
|
247 : &scope_chain->bindings))
|
|
|
248
|
|
|
249 /* The binding level of the current class, if any. */
|
|
|
250
|
|
|
251 #define class_binding_level scope_chain->class_bindings
|
|
|
252
|
|
|
253 /* True if SCOPE designates the global scope binding contour. */
|
|
|
254 #define global_scope_p(SCOPE) \
|
|
|
255 ((SCOPE) == NAMESPACE_LEVEL (global_namespace))
|
|
|
256
|
|
|
257 extern cp_binding_level *leave_scope (void);
|
|
|
258 extern bool kept_level_p (void);
|
|
|
259 extern bool global_bindings_p (void);
|
|
|
260 extern bool toplevel_bindings_p (void);
|
|
|
261 extern bool namespace_bindings_p (void);
|
|
|
262 extern bool local_bindings_p (void);
|
|
|
263 extern bool template_parm_scope_p (void);
|
|
|
264 extern scope_kind innermost_scope_kind (void);
|
|
|
265 extern cp_binding_level *begin_scope (scope_kind, tree);
|
|
|
266 extern void print_binding_stack (void);
|
|
|
267 extern void pop_everything (void);
|
|
|
268 extern void keep_next_level (bool);
|
|
|
269 extern bool is_ancestor (tree ancestor, tree descendant);
|
|
|
270 extern bool is_nested_namespace (tree parent, tree descendant,
|
|
|
271 bool inline_only = false);
|
|
|
272 extern tree push_scope (tree);
|
|
|
273 extern void pop_scope (tree);
|
|
|
274 extern tree push_inner_scope (tree);
|
|
|
275 extern void pop_inner_scope (tree, tree);
|
|
|
276 extern void push_binding_level (cp_binding_level *);
|
|
|
277
|
|
|
278 extern bool handle_namespace_attrs (tree, tree);
|
|
|
279 extern void pushlevel_class (void);
|
|
|
280 extern void poplevel_class (void);
|
|
|
281 extern tree lookup_name_prefer_type (tree, int);
|
|
|
282 extern tree lookup_name_real (tree, int, int, bool, int, int);
|
|
|
283 extern tree lookup_type_scope (tree, tag_scope);
|
|
|
284 extern tree get_namespace_binding (tree ns, tree id);
|
|
|
285 extern void set_global_binding (tree decl);
|
|
|
286 inline tree get_global_binding (tree id)
|
|
|
287 {
|
|
|
288 return get_namespace_binding (NULL_TREE, id);
|
|
|
289 }
|
|
145
|
290 extern tree lookup_qualified_name (tree, tree, int = 0, bool = true, /*hidden*/bool = false);
|
|
|
291 extern tree lookup_qualified_name (tree t, const char *p, int = 0, bool = true, bool = false);
|
|
111
|
292 extern tree lookup_name_nonclass (tree);
|
|
|
293 extern bool is_local_extern (tree);
|
|
|
294 extern bool pushdecl_class_level (tree);
|
|
|
295 extern tree pushdecl_namespace_level (tree, bool);
|
|
|
296 extern bool push_class_level_binding (tree, tree);
|
|
|
297 extern tree get_local_decls ();
|
|
|
298 extern int function_parm_depth (void);
|
|
|
299 extern tree cp_namespace_decls (tree);
|
|
|
300 extern void set_decl_namespace (tree, tree, bool);
|
|
|
301 extern void push_decl_namespace (tree);
|
|
|
302 extern void pop_decl_namespace (void);
|
|
|
303 extern void do_namespace_alias (tree, tree);
|
|
|
304 extern tree do_class_using_decl (tree, tree);
|
|
|
305 extern tree lookup_arg_dependent (tree, tree, vec<tree, va_gc> *);
|
|
131
|
306 extern tree search_anon_aggr (tree, tree, bool = false);
|
|
145
|
307 extern tree get_class_binding_direct (tree, tree, bool want_type = false);
|
|
|
308 extern tree get_class_binding (tree, tree, bool want_type = false);
|
|
131
|
309 extern tree *find_member_slot (tree klass, tree name);
|
|
|
310 extern tree *add_member_slot (tree klass, tree name);
|
|
111
|
311 extern void resort_type_member_vec (void *, void *,
|
|
|
312 gt_pointer_operator, void *);
|
|
|
313 extern void set_class_bindings (tree, unsigned extra = 0);
|
|
|
314 extern void insert_late_enum_def_bindings (tree, tree);
|
|
|
315 extern tree innermost_non_namespace_value (tree);
|
|
|
316 extern cxx_binding *outer_binding (tree, cxx_binding *, bool);
|
|
|
317 extern void cp_emit_debug_info_for_using (tree, tree);
|
|
|
318
|
|
145
|
319 extern void finish_nonmember_using_decl (tree scope, tree name);
|
|
|
320 extern void finish_using_directive (tree target, tree attribs);
|
|
111
|
321 extern tree pushdecl (tree, bool is_friend = false);
|
|
|
322 extern tree pushdecl_outermost_localscope (tree);
|
|
|
323 extern tree pushdecl_top_level (tree, bool is_friend = false);
|
|
|
324 extern tree pushdecl_top_level_and_finish (tree, tree);
|
|
|
325 extern tree pushtag (tree, tree, tag_scope);
|
|
|
326 extern int push_namespace (tree, bool make_inline = false);
|
|
|
327 extern void pop_namespace (void);
|
|
|
328 extern void push_nested_namespace (tree);
|
|
|
329 extern void pop_nested_namespace (tree);
|
|
|
330 extern void push_to_top_level (void);
|
|
|
331 extern void pop_from_top_level (void);
|
|
145
|
332 extern void maybe_save_operator_binding (tree);
|
|
|
333 extern void push_operator_bindings (void);
|
|
|
334 extern void discard_operator_bindings (tree);
|
|
111
|
335
|
|
|
336 #endif /* GCC_CP_NAME_LOOKUP_H */
|
