1/* Declarations for -*- C++ -*- name lookup routines.
2   Copyright (C) 2003-2022 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_function_parms, /* The scope containing function parameters.  */
204  sk_class,	     /* The scope containing the members of a class.  */
205  sk_scoped_enum,    /* The scope containing the enumerators of a C++11
206                        scoped enumeration.  */
207  sk_namespace,	     /* The scope containing the members of a
208			namespace, including the global scope.  */
209  sk_template_parms, /* A scope for template parameters.  */
210  sk_template_spec,  /* Like sk_template_parms, but for an explicit
211			specialization.  Since, by definition, an
212			explicit specialization is introduced by
213			"template <>", this scope is always empty.  */
214  sk_transaction,    /* A synchronized or atomic statement.  */
215  sk_omp	     /* An OpenMP structured block.  */
216};
217
218struct GTY(()) cp_class_binding {
219  cxx_binding *base;
220  /* The bound name.  */
221  tree identifier;
222};
223
224/* For each binding contour we allocate a binding_level structure
225   which records the names defined in that contour.
226   Contours include:
227    0) the global one
228    1) one for each function definition,
229       where internal declarations of the parameters appear.
230    2) one for each compound statement,
231       to record its declarations.
232
233   The current meaning of a name can be found by searching the levels
234   from the current one out to the global one.
235
236   Off to the side, may be the class_binding_level.  This exists only
237   to catch class-local declarations.  It is otherwise nonexistent.
238
239   Also there may be binding levels that catch cleanups that must be
240   run when exceptions occur.  Thus, to see whether a name is bound in
241   the current scope, it is not enough to look in the
242   CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
243   instead.  */
244
245struct GTY(()) cp_binding_level {
246  /* A chain of _DECL nodes for all variables, constants, functions,
247      and typedef types.  These are in the reverse of the order
248      supplied.  There may be OVERLOADs on this list, too, but they
249      are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
250  tree names;
251
252  /* Using directives.  */
253  vec<tree, va_gc> *using_directives;
254
255  /* For the binding level corresponding to a class, the entities
256      declared in the class or its base classes.  */
257  vec<cp_class_binding, va_gc> *class_shadowed;
258
259  /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
260      is used for all binding levels. The TREE_PURPOSE is the name of
261      the entity, the TREE_TYPE is the associated type.  In addition
262      the TREE_VALUE is the IDENTIFIER_TYPE_VALUE before we entered
263      the class.  */
264  tree type_shadowed;
265
266  /* For each level (except not the global one),
267      a chain of BLOCK nodes for all the levels
268      that were entered and exited one level down.  */
269  tree blocks;
270
271  /* The entity (namespace, class, function) the scope of which this
272      binding contour corresponds to.  Otherwise NULL.  */
273  tree this_entity;
274
275  /* The binding level which this one is contained in (inherits from).  */
276  cp_binding_level *level_chain;
277
278  /* STATEMENT_LIST for statements in this binding contour.
279      Only used at present for SK_CLEANUP temporary bindings.  */
280  tree statement_list;
281
282  /* Binding depth at which this level began.  */
283  int binding_depth;
284
285  /* The kind of scope that this object represents.  However, a
286      SK_TEMPLATE_SPEC scope is represented with KIND set to
287      SK_TEMPLATE_PARMS and EXPLICIT_SPEC_P set to true.  */
288  ENUM_BITFIELD (scope_kind) kind : 4;
289
290  /* True if this scope is an SK_TEMPLATE_SPEC scope.  This field is
291      only valid if KIND == SK_TEMPLATE_PARMS.  */
292  BOOL_BITFIELD explicit_spec_p : 1;
293
294  /* true means make a BLOCK for this level regardless of all else.  */
295  unsigned keep : 1;
296
297  /* Nonzero if this level can safely have additional
298      cleanup-needing variables added to it.  */
299  unsigned more_cleanups_ok : 1;
300  unsigned have_cleanups : 1;
301
302  /* Transient state set if this scope is of sk_class kind
303     and is in the process of defining 'this_entity'.  Reset
304     on leaving the class definition to allow for the scope
305     to be subsequently re-used as a non-defining scope for
306     'this_entity'.  */
307  unsigned defining_class_p : 1;
308
309  /* true for SK_FUNCTION_PARMS of immediate functions.  */
310  unsigned immediate_fn_ctx_p : 1;
311
312  /* True for SK_FUNCTION_PARMS of a requires-expression.  */
313  unsigned requires_expression: 1;
314
315  /* 21 bits left to fill a 32-bit word.  */
316};
317
318/* The binding level currently in effect.  */
319
320#define current_binding_level			\
321  (*(cfun && cp_function_chain && cp_function_chain->bindings \
322   ? &cp_function_chain->bindings		\
323   : &scope_chain->bindings))
324
325/* The binding level of the current class, if any.  */
326
327#define class_binding_level scope_chain->class_bindings
328
329/* True if SCOPE designates the global scope binding contour.  */
330#define global_scope_p(SCOPE) \
331  ((SCOPE) == NAMESPACE_LEVEL (global_namespace))
332
333extern cp_binding_level *leave_scope (void);
334extern bool kept_level_p (void);
335extern bool global_bindings_p (void);
336extern bool toplevel_bindings_p (void);
337extern bool namespace_bindings_p (void);
338extern bool local_bindings_p (void);
339extern bool template_parm_scope_p (void);
340extern scope_kind innermost_scope_kind (void);
341extern cp_binding_level *begin_scope (scope_kind, tree);
342extern void print_binding_stack	(void);
343extern void pop_everything (void);
344extern void keep_next_level (bool);
345extern bool is_ancestor (tree ancestor, tree descendant);
346extern bool is_nested_namespace (tree parent, tree descendant,
347				 bool inline_only = false);
348extern tree push_scope (tree);
349extern void pop_scope (tree);
350extern tree push_inner_scope (tree);
351extern void pop_inner_scope (tree, tree);
352extern void push_binding_level (cp_binding_level *);
353
354extern bool handle_namespace_attrs (tree, tree);
355extern void pushlevel_class (void);
356extern void poplevel_class (void);
357
358/* What kind of scopes name lookup looks in.  An enum class so we
359   don't accidentally mix integers.  */
360enum class LOOK_where
361{
362  BLOCK = 1 << 0,  /* Consider block scopes.  */
363  CLASS = 1 << 1,  /* Consider class scopes.  */
364  NAMESPACE = 1 << 2,  /* Consider namespace scopes.  */
365
366  ALL = BLOCK | CLASS | NAMESPACE,
367  BLOCK_NAMESPACE = BLOCK | NAMESPACE,
368  CLASS_NAMESPACE = CLASS | NAMESPACE,
369};
370constexpr LOOK_where operator| (LOOK_where a, LOOK_where b)
371{
372  return LOOK_where (unsigned (a) | unsigned (b));
373}
374constexpr LOOK_where operator& (LOOK_where a, LOOK_where b)
375{
376  return LOOK_where (unsigned (a) & unsigned (b));
377}
378
379enum class LOOK_want
380{
381  NORMAL = 0,  /* Normal lookup -- non-types can hide implicit types.  */
382  TYPE = 1 << 1,  /* We only want TYPE_DECLS.  */
383  NAMESPACE = 1 << 2,  /* We only want NAMESPACE_DECLS.  */
384
385  HIDDEN_FRIEND = 1 << 3, /* See hidden friends.  */
386  HIDDEN_LAMBDA = 1 << 4,  /* See lambda-ignored entities.  */
387
388  TYPE_NAMESPACE = TYPE | NAMESPACE,  /* Either NAMESPACE or TYPE.  */
389};
390constexpr LOOK_want operator| (LOOK_want a, LOOK_want b)
391{
392  return LOOK_want (unsigned (a) | unsigned (b));
393}
394constexpr LOOK_want operator& (LOOK_want a, LOOK_want b)
395{
396  return LOOK_want (unsigned (a) & unsigned (b));
397}
398
399extern tree lookup_name (tree, LOOK_where, LOOK_want = LOOK_want::NORMAL);
400/* Also declared in c-family/c-common.h.  */
401extern tree lookup_name (tree name);
402inline tree lookup_name (tree name, LOOK_want want)
403{
404  return lookup_name (name, LOOK_where::ALL, want);
405}
406
407enum class TAG_how
408{
409  CURRENT_ONLY = 0, // Look and insert only in current scope
410
411  GLOBAL = 1, // Unqualified lookup, innermost-non-class insertion
412
413  INNERMOST_NON_CLASS = 2, // Look and insert only into
414			   // innermost-non-class
415
416  HIDDEN_FRIEND = 3, // As INNERMOST_NON_CLASS, but hide it
417};
418
419extern tree lookup_elaborated_type (tree, TAG_how);
420extern tree get_namespace_binding (tree ns, tree id);
421extern void set_global_binding (tree decl);
422inline tree get_global_binding (tree id)
423{
424  return get_namespace_binding (NULL_TREE, id);
425}
426extern tree lookup_qualified_name (tree scope, tree name,
427				   LOOK_want = LOOK_want::NORMAL,
428				   bool = true);
429extern tree lookup_qualified_name (tree scope, const char *name,
430				   LOOK_want = LOOK_want::NORMAL,
431				   bool = true);
432extern bool pushdecl_class_level (tree);
433extern tree pushdecl_namespace_level (tree, bool hiding = false);
434extern bool push_class_level_binding (tree, tree);
435extern tree get_local_decls ();
436extern int function_parm_depth (void);
437extern tree cp_namespace_decls (tree);
438extern void set_decl_namespace (tree, tree, bool);
439extern void push_decl_namespace (tree);
440extern void pop_decl_namespace (void);
441extern void do_namespace_alias (tree, tree);
442extern tree do_class_using_decl (tree, tree);
443extern tree lookup_arg_dependent (tree, tree, vec<tree, va_gc> *);
444extern tree search_anon_aggr (tree, tree, bool = false);
445extern tree get_class_binding_direct (tree, tree, bool want_type = false);
446extern tree get_class_binding (tree, tree, bool want_type = false);
447extern tree *find_member_slot (tree klass, tree name);
448extern tree *add_member_slot (tree klass, tree name);
449extern void resort_type_member_vec (void *, void *,
450				    gt_pointer_operator, void *);
451extern vec<tree, va_gc> *set_class_bindings (tree, int extra = 0);
452extern void insert_late_enum_def_bindings (tree, tree);
453extern tree innermost_non_namespace_value (tree);
454extern cxx_binding *outer_binding (tree, cxx_binding *, bool);
455extern void cp_emit_debug_info_for_using (tree, tree);
456
457extern void finish_nonmember_using_decl (tree scope, tree name);
458extern void finish_using_directive (tree target, tree attribs);
459void push_local_extern_decl_alias (tree decl);
460extern tree pushdecl (tree, bool hiding = false);
461extern tree pushdecl_outermost_localscope (tree);
462extern tree pushdecl_top_level (tree);
463extern tree pushdecl_top_level_and_finish (tree, tree);
464extern tree pushtag (tree, tree, TAG_how = TAG_how::CURRENT_ONLY);
465extern int push_namespace (tree, bool make_inline = false);
466extern void pop_namespace (void);
467extern void push_nested_namespace (tree);
468extern void pop_nested_namespace (tree);
469extern void push_to_top_level (void);
470extern void pop_from_top_level (void);
471extern void push_using_decl_bindings (tree, tree);
472
473/* Lower level interface for modules. */
474extern tree *mergeable_namespace_slots (tree ns, tree name, bool is_global,
475					tree *mvec);
476extern void add_mergeable_namespace_entity (tree *slot, tree decl);
477extern tree lookup_class_binding (tree ctx, tree name);
478extern bool import_module_binding (tree ctx, tree name, unsigned mod,
479				   unsigned snum);
480extern bool set_module_binding (tree ctx, tree name, unsigned mod,
481				int mod_glob_flag,
482				tree value, tree type, tree visible);
483extern void add_module_namespace_decl (tree ns, tree decl);
484
485enum WMB_Flags
486{
487  WMB_None = 0,
488  WMB_Dups = 1 << 0,
489  WMB_Export = 1 << 1,
490  WMB_Using = 1 << 2,
491  WMB_Hidden = 1 << 3,
492};
493
494extern unsigned walk_module_binding (tree binding, bitmap partitions,
495				     bool (*)(tree decl, WMB_Flags, void *data),
496				     void *data);
497extern tree add_imported_namespace (tree ctx, tree name, location_t,
498				    unsigned module,
499				    bool inline_p, bool visible_p);
500extern const char *get_cxx_dialect_name (enum cxx_dialect dialect);
501
502#endif /* GCC_CP_NAME_LOOKUP_H */
503