LCOV - code coverage report
Current view: top level - gcc/cp - name-lookup.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 2 2 100.0 %
Date: 2020-03-28 11:57:23 Functions: 0 0 -
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Declarations for -*- C++ -*- name lookup routines.
       2                 :            :    Copyright (C) 2003-2020 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                 :            : #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.  */
     115                 :            :   sk_scoped_enum,    /* The scope containing the enumerators of a C++11
     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                 :            : 
     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.  */
     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                 :    3074359 : inline tree get_global_binding (tree id)
     287                 :            : {
     288                 :    3069299 :   return get_namespace_binding (NULL_TREE, id);
     289                 :            : }
     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);
     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> *);
     306                 :            : extern tree search_anon_aggr (tree, tree, bool = false);
     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);
     309                 :            : extern tree *find_member_slot (tree klass, tree name);
     310                 :            : extern tree *add_member_slot (tree klass, tree name);
     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                 :            : 
     319                 :            : extern void finish_nonmember_using_decl (tree scope, tree name);
     320                 :            : extern void finish_using_directive (tree target, tree attribs);
     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);
     332                 :            : extern void maybe_save_operator_binding (tree);
     333                 :            : extern void push_operator_bindings (void);
     334                 :            : extern void discard_operator_bindings (tree);
     335                 :            : 
     336                 :            : #endif /* GCC_CP_NAME_LOOKUP_H */

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.