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

           Branch data     Line data    Source code
       1                 :            : /* Definitions for C++ parsing and type checking.
       2                 :            :    Copyright (C) 1987-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Michael Tiemann (tiemann@cygnus.com)
       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_TREE_H
      22                 :            : #define GCC_CP_TREE_H
      23                 :            : 
      24                 :            : #include "tm.h"
      25                 :            : #include "hard-reg-set.h"
      26                 :            : #include "function.h"
      27                 :            : 
      28                 :            : /* In order for the format checking to accept the C++ front end
      29                 :            :    diagnostic framework extensions, you must include this file before
      30                 :            :    diagnostic-core.h, not after.  We override the definition of GCC_DIAG_STYLE
      31                 :            :    in c-common.h.  */
      32                 :            : #undef GCC_DIAG_STYLE
      33                 :            : #define GCC_DIAG_STYLE __gcc_cxxdiag__
      34                 :            : #if defined(GCC_DIAGNOSTIC_CORE_H) || defined (GCC_C_COMMON_H)
      35                 :            : #error \
      36                 :            : In order for the format checking to accept the C++ front end diagnostic \
      37                 :            : framework extensions, you must include this file before diagnostic-core.h and \
      38                 :            : c-common.h, not after.
      39                 :            : #endif
      40                 :            : #include "c-family/c-common.h"
      41                 :            : #include "diagnostic.h"
      42                 :            : 
      43                 :            : /* A tree node, together with a location, so that we can track locations
      44                 :            :    (and ranges) during parsing.
      45                 :            : 
      46                 :            :    The location is redundant for node kinds that have locations,
      47                 :            :    but not all node kinds do (e.g. constants, and references to
      48                 :            :    params, locals, etc), so we stash a copy here.  */
      49                 :            : 
      50                 :            : extern location_t cp_expr_location              (const_tree);
      51                 :            : 
      52                 :            : class cp_expr
      53                 :            : {
      54                 :            : public:
      55                 :  957556000 :   cp_expr () :
      56                 :  957556000 :     m_value (NULL), m_loc (UNKNOWN_LOCATION) {}
      57                 :            : 
      58                 :  319589821 :   cp_expr (tree value) :
      59                 :  318159552 :     m_value (value), m_loc (cp_expr_location (m_value)) {}
      60                 :            : 
      61                 :  722674503 :   cp_expr (tree value, location_t loc):
      62                 :     571302 :     m_value (value), m_loc (loc)
      63                 :            :   {
      64                 :  722674503 :     protected_set_expr_location (value, loc);
      65                 :            :   }
      66                 :            : 
      67                 :            :   /* Implicit conversions to tree.  */
      68                 : 1034082123 :   operator tree () const { return m_value; }
      69                 :      91121 :   tree & operator* () { return m_value; }
      70                 :            :   tree operator* () const { return m_value; }
      71                 :  127976154 :   tree & operator-> () { return m_value; }
      72                 :            :   tree operator-> () const { return m_value; }
      73                 :            : 
      74                 :   75342103 :   tree get_value () const { return m_value; }
      75                 :  190282316 :   location_t get_location () const { return m_loc; }
      76                 :   20095345 :   location_t get_start () const
      77                 :            :   {
      78                 :   20095345 :     source_range src_range = get_range_from_loc (line_table, m_loc);
      79                 :   20095345 :     return src_range.m_start;
      80                 :            :   }
      81                 :   23324458 :   location_t get_finish () const
      82                 :            :   {
      83                 :   23324458 :     source_range src_range = get_range_from_loc (line_table, m_loc);
      84                 :   23324458 :     return src_range.m_finish;
      85                 :            :   }
      86                 :            : 
      87                 :   87043758 :   void set_location (location_t loc)
      88                 :            :   {
      89                 :   79919858 :     protected_set_expr_location (m_value, loc);
      90                 :   66139768 :     m_loc = loc;
      91                 :   15678700 :   }
      92                 :            : 
      93                 :    5169058 :   void set_range (location_t start, location_t finish)
      94                 :            :   {
      95                 :    5169058 :     set_location (make_location (m_loc, start, finish));
      96                 :    5169058 :   }
      97                 :            : 
      98                 :   45750046 :   cp_expr& maybe_add_location_wrapper ()
      99                 :            :   {
     100                 :   57681300 :     m_value = maybe_wrap_with_location (m_value, m_loc);
     101                 :   77991100 :     return *this;
     102                 :            :   }
     103                 :            : 
     104                 :            :  private:
     105                 :            :   tree m_value;
     106                 :            :   location_t m_loc;
     107                 :            : };
     108                 :            : 
     109                 :            : inline bool
     110                 :  102377804 : operator == (const cp_expr &lhs, tree rhs)
     111                 :            : {
     112                 :  102129746 :   return lhs.get_value () == rhs;
     113                 :            : }
     114                 :            : 
     115                 :            : 
     116                 :            : enum cp_tree_index
     117                 :            : {
     118                 :            :     CPTI_WCHAR_DECL,
     119                 :            :     CPTI_VTABLE_ENTRY_TYPE,
     120                 :            :     CPTI_DELTA_TYPE,
     121                 :            :     CPTI_VTABLE_INDEX_TYPE,
     122                 :            :     CPTI_CLEANUP_TYPE,
     123                 :            :     CPTI_VTT_PARM_TYPE,
     124                 :            : 
     125                 :            :     CPTI_CLASS_TYPE,
     126                 :            :     CPTI_UNKNOWN_TYPE,
     127                 :            :     CPTI_INIT_LIST_TYPE,
     128                 :            :     CPTI_VTBL_TYPE,
     129                 :            :     CPTI_VTBL_PTR_TYPE,
     130                 :            :     CPTI_STD,
     131                 :            :     CPTI_ABI,
     132                 :            :     CPTI_GLOBAL,
     133                 :            :     CPTI_GLOBAL_TYPE,
     134                 :            :     CPTI_CONST_TYPE_INFO_TYPE,
     135                 :            :     CPTI_TYPE_INFO_PTR_TYPE,
     136                 :            :     CPTI_ABORT_FNDECL,
     137                 :            :     CPTI_AGGR_TAG,
     138                 :            :     CPTI_CONV_OP_MARKER,
     139                 :            : 
     140                 :            :     CPTI_CTOR_IDENTIFIER,
     141                 :            :     CPTI_COMPLETE_CTOR_IDENTIFIER,
     142                 :            :     CPTI_BASE_CTOR_IDENTIFIER,
     143                 :            :     CPTI_DTOR_IDENTIFIER,
     144                 :            :     CPTI_COMPLETE_DTOR_IDENTIFIER,
     145                 :            :     CPTI_BASE_DTOR_IDENTIFIER,
     146                 :            :     CPTI_DELETING_DTOR_IDENTIFIER,
     147                 :            :     CPTI_CONV_OP_IDENTIFIER,
     148                 :            :     CPTI_DELTA_IDENTIFIER,
     149                 :            :     CPTI_IN_CHARGE_IDENTIFIER,
     150                 :            :     CPTI_VTT_PARM_IDENTIFIER,
     151                 :            :     CPTI_THIS_IDENTIFIER,
     152                 :            :     CPTI_PFN_IDENTIFIER,
     153                 :            :     CPTI_VPTR_IDENTIFIER,
     154                 :            :     CPTI_GLOBAL_IDENTIFIER,
     155                 :            :     CPTI_ANON_IDENTIFIER,
     156                 :            :     CPTI_AUTO_IDENTIFIER,
     157                 :            :     CPTI_DECLTYPE_AUTO_IDENTIFIER,
     158                 :            :     CPTI_INIT_LIST_IDENTIFIER,
     159                 :            :     CPTI_FOR_RANGE__IDENTIFIER,
     160                 :            :     CPTI_FOR_BEGIN__IDENTIFIER,
     161                 :            :     CPTI_FOR_END__IDENTIFIER,
     162                 :            :     CPTI_FOR_RANGE_IDENTIFIER,
     163                 :            :     CPTI_FOR_BEGIN_IDENTIFIER,
     164                 :            :     CPTI_FOR_END_IDENTIFIER,
     165                 :            :     CPTI_ABI_TAG_IDENTIFIER,
     166                 :            :     CPTI_ALIGNED_IDENTIFIER,
     167                 :            :     CPTI_BEGIN_IDENTIFIER,
     168                 :            :     CPTI_END_IDENTIFIER,
     169                 :            :     CPTI_GET_IDENTIFIER,
     170                 :            :     CPTI_GNU_IDENTIFIER,
     171                 :            :     CPTI_TUPLE_ELEMENT_IDENTIFIER,
     172                 :            :     CPTI_TUPLE_SIZE_IDENTIFIER,
     173                 :            :     CPTI_TYPE_IDENTIFIER,
     174                 :            :     CPTI_VALUE_IDENTIFIER,
     175                 :            :     CPTI_FUN_IDENTIFIER,
     176                 :            :     CPTI_CLOSURE_IDENTIFIER,
     177                 :            :     CPTI_HEAP_UNINIT_IDENTIFIER,
     178                 :            :     CPTI_HEAP_IDENTIFIER,
     179                 :            :     CPTI_HEAP_DELETED_IDENTIFIER,
     180                 :            : 
     181                 :            :     CPTI_LANG_NAME_C,
     182                 :            :     CPTI_LANG_NAME_CPLUSPLUS,
     183                 :            : 
     184                 :            :     CPTI_EMPTY_EXCEPT_SPEC,
     185                 :            :     CPTI_NOEXCEPT_TRUE_SPEC,
     186                 :            :     CPTI_NOEXCEPT_FALSE_SPEC,
     187                 :            :     CPTI_NOEXCEPT_DEFERRED_SPEC,
     188                 :            : 
     189                 :            :     CPTI_TERMINATE_FN,
     190                 :            :     CPTI_CALL_UNEXPECTED_FN,
     191                 :            :     CPTI_GET_EXCEPTION_PTR_FN,
     192                 :            :     CPTI_BEGIN_CATCH_FN,
     193                 :            :     CPTI_END_CATCH_FN,
     194                 :            :     CPTI_ALLOCATE_EXCEPTION_FN,
     195                 :            :     CPTI_FREE_EXCEPTION_FN,
     196                 :            :     CPTI_THROW_FN,
     197                 :            :     CPTI_RETHROW_FN,
     198                 :            :     CPTI_ATEXIT_FN_PTR_TYPE,
     199                 :            :     CPTI_ATEXIT,
     200                 :            :     CPTI_DSO_HANDLE,
     201                 :            :     CPTI_DCAST,
     202                 :            : 
     203                 :            :     CPTI_NULLPTR,
     204                 :            :     CPTI_NULLPTR_TYPE,
     205                 :            : 
     206                 :            :     CPTI_ALIGN_TYPE,
     207                 :            : 
     208                 :            :     CPTI_ANY_TARG,
     209                 :            : 
     210                 :            :     CPTI_SOURCE_LOCATION_IMPL,
     211                 :            : 
     212                 :            :     CPTI_FALLBACK_DFLOAT32_TYPE,
     213                 :            :     CPTI_FALLBACK_DFLOAT64_TYPE,
     214                 :            :     CPTI_FALLBACK_DFLOAT128_TYPE,
     215                 :            : 
     216                 :            :     CPTI_MAX
     217                 :            : };
     218                 :            : 
     219                 :            : extern GTY(()) tree cp_global_trees[CPTI_MAX];
     220                 :            : 
     221                 :            : #define wchar_decl_node                 cp_global_trees[CPTI_WCHAR_DECL]
     222                 :            : #define vtable_entry_type               cp_global_trees[CPTI_VTABLE_ENTRY_TYPE]
     223                 :            : /* The type used to represent an offset by which to adjust the `this'
     224                 :            :    pointer in pointer-to-member types.  */
     225                 :            : #define delta_type_node                 cp_global_trees[CPTI_DELTA_TYPE]
     226                 :            : /* The type used to represent an index into the vtable.  */
     227                 :            : #define vtable_index_type               cp_global_trees[CPTI_VTABLE_INDEX_TYPE]
     228                 :            : 
     229                 :            : #define class_type_node                 cp_global_trees[CPTI_CLASS_TYPE]
     230                 :            : #define unknown_type_node               cp_global_trees[CPTI_UNKNOWN_TYPE]
     231                 :            : #define init_list_type_node             cp_global_trees[CPTI_INIT_LIST_TYPE]
     232                 :            : #define vtbl_type_node                  cp_global_trees[CPTI_VTBL_TYPE]
     233                 :            : #define vtbl_ptr_type_node              cp_global_trees[CPTI_VTBL_PTR_TYPE]
     234                 :            : #define std_node                        cp_global_trees[CPTI_STD]
     235                 :            : #define abi_node                        cp_global_trees[CPTI_ABI]
     236                 :            : #define global_namespace                cp_global_trees[CPTI_GLOBAL]
     237                 :            : #define global_type_node                cp_global_trees[CPTI_GLOBAL_TYPE]
     238                 :            : #define const_type_info_type_node       cp_global_trees[CPTI_CONST_TYPE_INFO_TYPE]
     239                 :            : #define type_info_ptr_type              cp_global_trees[CPTI_TYPE_INFO_PTR_TYPE]
     240                 :            : #define conv_op_marker                  cp_global_trees[CPTI_CONV_OP_MARKER]
     241                 :            : #define abort_fndecl                    cp_global_trees[CPTI_ABORT_FNDECL]
     242                 :            : #define current_aggr                    cp_global_trees[CPTI_AGGR_TAG]
     243                 :            : #define nullptr_node                    cp_global_trees[CPTI_NULLPTR]
     244                 :            : #define nullptr_type_node               cp_global_trees[CPTI_NULLPTR_TYPE]
     245                 :            : /* std::align_val_t */
     246                 :            : #define align_type_node                 cp_global_trees[CPTI_ALIGN_TYPE]
     247                 :            : 
     248                 :            : /* We cache these tree nodes so as to call get_identifier less frequently.
     249                 :            :    For identifiers for functions, including special member functions such
     250                 :            :    as ctors and assignment operators, the nodes can be used (among other
     251                 :            :    things) to iterate over their overloads defined by/for a type.  For
     252                 :            :    example:
     253                 :            : 
     254                 :            :      tree ovlid = assign_op_identifier;
     255                 :            :      tree overloads = get_class_binding (type, ovlid);
     256                 :            :      for (ovl_iterator it (overloads); it; ++it) { ... }
     257                 :            : 
     258                 :            :    iterates over the set of implicitly and explicitly defined overloads
     259                 :            :    of the assignment operator for type (including the copy and move
     260                 :            :    assignment operators, whether deleted or not).  */
     261                 :            : 
     262                 :            : /* The name of a constructor that takes an in-charge parameter to
     263                 :            :    decide whether or not to construct virtual base classes.  */
     264                 :            : #define ctor_identifier                 cp_global_trees[CPTI_CTOR_IDENTIFIER]
     265                 :            : /* The name of a constructor that constructs virtual base classes.  */
     266                 :            : #define complete_ctor_identifier        cp_global_trees[CPTI_COMPLETE_CTOR_IDENTIFIER]
     267                 :            : /* The name of a constructor that does not construct virtual base classes.  */
     268                 :            : #define base_ctor_identifier            cp_global_trees[CPTI_BASE_CTOR_IDENTIFIER]
     269                 :            : /* The name of a destructor that takes an in-charge parameter to
     270                 :            :    decide whether or not to destroy virtual base classes and whether
     271                 :            :    or not to delete the object.  */
     272                 :            : #define dtor_identifier                 cp_global_trees[CPTI_DTOR_IDENTIFIER]
     273                 :            : /* The name of a destructor that destroys virtual base classes.  */
     274                 :            : #define complete_dtor_identifier        cp_global_trees[CPTI_COMPLETE_DTOR_IDENTIFIER]
     275                 :            : /* The name of a destructor that does not destroy virtual base
     276                 :            :    classes.  */
     277                 :            : #define base_dtor_identifier            cp_global_trees[CPTI_BASE_DTOR_IDENTIFIER]
     278                 :            : /* The name of a destructor that destroys virtual base classes, and
     279                 :            :    then deletes the entire object.  */
     280                 :            : #define deleting_dtor_identifier        cp_global_trees[CPTI_DELETING_DTOR_IDENTIFIER]
     281                 :            : 
     282                 :            : /* The name used for conversion operators -- but note that actual
     283                 :            :    conversion functions use special identifiers outside the identifier
     284                 :            :    table.  */
     285                 :            : #define conv_op_identifier              cp_global_trees[CPTI_CONV_OP_IDENTIFIER]
     286                 :            : 
     287                 :            : #define delta_identifier                cp_global_trees[CPTI_DELTA_IDENTIFIER]
     288                 :            : #define in_charge_identifier            cp_global_trees[CPTI_IN_CHARGE_IDENTIFIER]
     289                 :            : /* The name of the parameter that contains a pointer to the VTT to use
     290                 :            :    for this subobject constructor or destructor.  */
     291                 :            : #define vtt_parm_identifier             cp_global_trees[CPTI_VTT_PARM_IDENTIFIER]
     292                 :            : #define this_identifier                 cp_global_trees[CPTI_THIS_IDENTIFIER]
     293                 :            : #define pfn_identifier                  cp_global_trees[CPTI_PFN_IDENTIFIER]
     294                 :            : #define vptr_identifier                 cp_global_trees[CPTI_VPTR_IDENTIFIER]
     295                 :            : /* The name of the ::, std & anon namespaces.  */
     296                 :            : #define global_identifier               cp_global_trees[CPTI_GLOBAL_IDENTIFIER]
     297                 :            : #define anon_identifier                 cp_global_trees[CPTI_ANON_IDENTIFIER]
     298                 :            : /* auto and declspec(auto) identifiers.  */
     299                 :            : #define auto_identifier                 cp_global_trees[CPTI_AUTO_IDENTIFIER]
     300                 :            : #define decltype_auto_identifier        cp_global_trees[CPTI_DECLTYPE_AUTO_IDENTIFIER]
     301                 :            : #define init_list_identifier            cp_global_trees[CPTI_INIT_LIST_IDENTIFIER]
     302                 :            : #define for_range__identifier           cp_global_trees[CPTI_FOR_RANGE__IDENTIFIER]
     303                 :            : #define for_begin__identifier           cp_global_trees[CPTI_FOR_BEGIN__IDENTIFIER]
     304                 :            : #define for_end__identifier             cp_global_trees[CPTI_FOR_END__IDENTIFIER]
     305                 :            : #define for_range_identifier            cp_global_trees[CPTI_FOR_RANGE_IDENTIFIER]
     306                 :            : #define for_begin_identifier            cp_global_trees[CPTI_FOR_BEGIN_IDENTIFIER]
     307                 :            : #define for_end_identifier              cp_global_trees[CPTI_FOR_END_IDENTIFIER]
     308                 :            : #define abi_tag_identifier              cp_global_trees[CPTI_ABI_TAG_IDENTIFIER]
     309                 :            : #define aligned_identifier              cp_global_trees[CPTI_ALIGNED_IDENTIFIER]
     310                 :            : #define begin_identifier                cp_global_trees[CPTI_BEGIN_IDENTIFIER]
     311                 :            : #define end_identifier                  cp_global_trees[CPTI_END_IDENTIFIER]
     312                 :            : #define get__identifier                 cp_global_trees[CPTI_GET_IDENTIFIER]
     313                 :            : #define gnu_identifier                  cp_global_trees[CPTI_GNU_IDENTIFIER]
     314                 :            : #define tuple_element_identifier        cp_global_trees[CPTI_TUPLE_ELEMENT_IDENTIFIER]
     315                 :            : #define tuple_size_identifier           cp_global_trees[CPTI_TUPLE_SIZE_IDENTIFIER]
     316                 :            : #define type_identifier                 cp_global_trees[CPTI_TYPE_IDENTIFIER]
     317                 :            : #define value_identifier                cp_global_trees[CPTI_VALUE_IDENTIFIER]
     318                 :            : #define fun_identifier                  cp_global_trees[CPTI_FUN_IDENTIFIER]
     319                 :            : #define closure_identifier              cp_global_trees[CPTI_CLOSURE_IDENTIFIER]
     320                 :            : #define heap_uninit_identifier          cp_global_trees[CPTI_HEAP_UNINIT_IDENTIFIER]
     321                 :            : #define heap_identifier                 cp_global_trees[CPTI_HEAP_IDENTIFIER]
     322                 :            : #define heap_deleted_identifier         cp_global_trees[CPTI_HEAP_DELETED_IDENTIFIER]
     323                 :            : #define lang_name_c                     cp_global_trees[CPTI_LANG_NAME_C]
     324                 :            : #define lang_name_cplusplus             cp_global_trees[CPTI_LANG_NAME_CPLUSPLUS]
     325                 :            : 
     326                 :            : /* Exception specifiers used for throw(), noexcept(true),
     327                 :            :    noexcept(false) and deferred noexcept.  We rely on these being
     328                 :            :    uncloned.  */
     329                 :            : #define empty_except_spec               cp_global_trees[CPTI_EMPTY_EXCEPT_SPEC]
     330                 :            : #define noexcept_true_spec              cp_global_trees[CPTI_NOEXCEPT_TRUE_SPEC]
     331                 :            : #define noexcept_false_spec             cp_global_trees[CPTI_NOEXCEPT_FALSE_SPEC]
     332                 :            : #define noexcept_deferred_spec          cp_global_trees[CPTI_NOEXCEPT_DEFERRED_SPEC]
     333                 :            : 
     334                 :            : /* Exception handling function declarations.  */
     335                 :            : #define terminate_fn                    cp_global_trees[CPTI_TERMINATE_FN]
     336                 :            : #define call_unexpected_fn              cp_global_trees[CPTI_CALL_UNEXPECTED_FN]
     337                 :            : #define get_exception_ptr_fn            cp_global_trees[CPTI_GET_EXCEPTION_PTR_FN]
     338                 :            : #define begin_catch_fn                  cp_global_trees[CPTI_BEGIN_CATCH_FN]
     339                 :            : #define end_catch_fn                    cp_global_trees[CPTI_END_CATCH_FN]
     340                 :            : #define allocate_exception_fn           cp_global_trees[CPTI_ALLOCATE_EXCEPTION_FN]
     341                 :            : #define free_exception_fn               cp_global_trees[CPTI_FREE_EXCEPTION_FN]
     342                 :            : #define throw_fn                        cp_global_trees[CPTI_THROW_FN]
     343                 :            : #define rethrow_fn                      cp_global_trees[CPTI_RETHROW_FN]
     344                 :            : 
     345                 :            : /* The type of the function-pointer argument to "__cxa_atexit" (or
     346                 :            :    "std::atexit", if "__cxa_atexit" is not being used).  */
     347                 :            : #define atexit_fn_ptr_type_node         cp_global_trees[CPTI_ATEXIT_FN_PTR_TYPE]
     348                 :            : 
     349                 :            : /* A pointer to `std::atexit'.  */
     350                 :            : #define atexit_node                     cp_global_trees[CPTI_ATEXIT]
     351                 :            : 
     352                 :            : /* A pointer to `__dso_handle'.  */
     353                 :            : #define dso_handle_node                 cp_global_trees[CPTI_DSO_HANDLE]
     354                 :            : 
     355                 :            : /* The declaration of the dynamic_cast runtime.  */
     356                 :            : #define dynamic_cast_node               cp_global_trees[CPTI_DCAST]
     357                 :            : 
     358                 :            : /* The type of a destructor.  */
     359                 :            : #define cleanup_type                    cp_global_trees[CPTI_CLEANUP_TYPE]
     360                 :            : 
     361                 :            : /* The type of the vtt parameter passed to subobject constructors and
     362                 :            :    destructors.  */
     363                 :            : #define vtt_parm_type                   cp_global_trees[CPTI_VTT_PARM_TYPE]
     364                 :            : 
     365                 :            : /* A node which matches any template argument.  */
     366                 :            : #define any_targ_node                   cp_global_trees[CPTI_ANY_TARG]
     367                 :            : 
     368                 :            : /* std::source_location::__impl class.  */
     369                 :            : #define source_location_impl            cp_global_trees[CPTI_SOURCE_LOCATION_IMPL]
     370                 :            : 
     371                 :            : /* Node to indicate default access. This must be distinct from the
     372                 :            :    access nodes in tree.h.  */
     373                 :            : 
     374                 :            : #define access_default_node             null_node
     375                 :            : 
     376                 :            : /* Variant of dfloat{32,64,128}_type_node only used for fundamental
     377                 :            :    rtti purposes if DFP is disabled.  */
     378                 :            : #define fallback_dfloat32_type          cp_global_trees[CPTI_FALLBACK_DFLOAT32_TYPE]
     379                 :            : #define fallback_dfloat64_type          cp_global_trees[CPTI_FALLBACK_DFLOAT64_TYPE]
     380                 :            : #define fallback_dfloat128_type         cp_global_trees[CPTI_FALLBACK_DFLOAT128_TYPE]
     381                 :            : 
     382                 :            : 
     383                 :            : #include "name-lookup.h"
     384                 :            : 
     385                 :            : /* Usage of TREE_LANG_FLAG_?:
     386                 :            :    0: IDENTIFIER_KIND_BIT_0 (in IDENTIFIER_NODE)
     387                 :            :       NEW_EXPR_USE_GLOBAL (in NEW_EXPR).
     388                 :            :       COND_EXPR_IS_VEC_DELETE (in COND_EXPR).
     389                 :            :       DELETE_EXPR_USE_GLOBAL (in DELETE_EXPR).
     390                 :            :       COMPOUND_EXPR_OVERLOADED (in COMPOUND_EXPR).
     391                 :            :       CLEANUP_P (in TRY_BLOCK)
     392                 :            :       AGGR_INIT_VIA_CTOR_P (in AGGR_INIT_EXPR)
     393                 :            :       PTRMEM_OK_P (in ADDR_EXPR, OFFSET_REF, SCOPE_REF)
     394                 :            :       PAREN_STRING_LITERAL (in STRING_CST)
     395                 :            :       CP_DECL_THREAD_LOCAL_P (in VAR_DECL)
     396                 :            :       KOENIG_LOOKUP_P (in CALL_EXPR)
     397                 :            :       STATEMENT_LIST_NO_SCOPE (in STATEMENT_LIST).
     398                 :            :       EXPR_STMT_STMT_EXPR_RESULT (in EXPR_STMT)
     399                 :            :       STMT_EXPR_NO_SCOPE (in STMT_EXPR)
     400                 :            :       BIND_EXPR_TRY_BLOCK (in BIND_EXPR)
     401                 :            :       TYPENAME_IS_ENUM_P (in TYPENAME_TYPE)
     402                 :            :       OMP_FOR_GIMPLIFYING_P (in OMP_FOR, OMP_SIMD, OMP_DISTRIBUTE,
     403                 :            :                              and OMP_TASKLOOP)
     404                 :            :       BASELINK_QUALIFIED_P (in BASELINK)
     405                 :            :       TARGET_EXPR_IMPLICIT_P (in TARGET_EXPR)
     406                 :            :       TEMPLATE_PARM_PARAMETER_PACK (in TEMPLATE_PARM_INDEX)
     407                 :            :       ATTR_IS_DEPENDENT (in the TREE_LIST for an attribute)
     408                 :            :       ABI_TAG_IMPLICIT (in the TREE_LIST for the argument of abi_tag)
     409                 :            :       LAMBDA_CAPTURE_EXPLICIT_P (in a TREE_LIST in LAMBDA_EXPR_CAPTURE_LIST)
     410                 :            :       CONSTRUCTOR_IS_DIRECT_INIT (in CONSTRUCTOR)
     411                 :            :       LAMBDA_EXPR_CAPTURES_THIS_P (in LAMBDA_EXPR)
     412                 :            :       DECLTYPE_FOR_LAMBDA_CAPTURE (in DECLTYPE_TYPE)
     413                 :            :       VEC_INIT_EXPR_IS_CONSTEXPR (in VEC_INIT_EXPR)
     414                 :            :       DECL_OVERRIDE_P (in FUNCTION_DECL)
     415                 :            :       IMPLICIT_CONV_EXPR_DIRECT_INIT (in IMPLICIT_CONV_EXPR)
     416                 :            :       TRANSACTION_EXPR_IS_STMT (in TRANSACTION_EXPR)
     417                 :            :       CONVERT_EXPR_VBASE_PATH (in CONVERT_EXPR)
     418                 :            :       PACK_EXPANSION_LOCAL_P (in *_PACK_EXPANSION)
     419                 :            :       TINFO_HAS_ACCESS_ERRORS (in TEMPLATE_INFO)
     420                 :            :       SIZEOF_EXPR_TYPE_P (in SIZEOF_EXPR)
     421                 :            :       COMPOUND_REQ_NOEXCEPT_P (in COMPOUND_REQ)
     422                 :            :       WILDCARD_PACK_P (in WILDCARD_DECL)
     423                 :            :       BLOCK_OUTER_CURLY_BRACE_P (in BLOCK)
     424                 :            :       FOLD_EXPR_MODOP_P (*_FOLD_EXPR)
     425                 :            :       IF_STMT_CONSTEXPR_P (IF_STMT)
     426                 :            :       TEMPLATE_TYPE_PARM_FOR_CLASS (TEMPLATE_TYPE_PARM)
     427                 :            :       DECL_NAMESPACE_INLINE_P (in NAMESPACE_DECL)
     428                 :            :       SWITCH_STMT_ALL_CASES_P (in SWITCH_STMT)
     429                 :            :       REINTERPRET_CAST_P (in NOP_EXPR)
     430                 :            :       ALIGNOF_EXPR_STD_P (in ALIGNOF_EXPR)
     431                 :            :       OVL_DEDUP_P (in OVERLOAD)
     432                 :            :    1: IDENTIFIER_KIND_BIT_1 (in IDENTIFIER_NODE)
     433                 :            :       TI_PENDING_TEMPLATE_FLAG.
     434                 :            :       TEMPLATE_PARMS_FOR_INLINE.
     435                 :            :       DELETE_EXPR_USE_VEC (in DELETE_EXPR).
     436                 :            :       (TREE_CALLS_NEW) (in _EXPR or _REF) (commented-out).
     437                 :            :       ICS_ELLIPSIS_FLAG (in _CONV)
     438                 :            :       DECL_INITIALIZED_P (in VAR_DECL)
     439                 :            :       TYPENAME_IS_CLASS_P (in TYPENAME_TYPE)
     440                 :            :       STMT_IS_FULL_EXPR_P (in _STMT)
     441                 :            :       TARGET_EXPR_LIST_INIT_P (in TARGET_EXPR)
     442                 :            :       LAMBDA_EXPR_MUTABLE_P (in LAMBDA_EXPR)
     443                 :            :       DECL_FINAL_P (in FUNCTION_DECL)
     444                 :            :       QUALIFIED_NAME_IS_TEMPLATE (in SCOPE_REF)
     445                 :            :       CONSTRUCTOR_IS_DEPENDENT (in CONSTRUCTOR)
     446                 :            :       TINFO_USED_TEMPLATE_ID (in TEMPLATE_INFO)
     447                 :            :       PACK_EXPANSION_SIZEOF_P (in *_PACK_EXPANSION)
     448                 :            :       OVL_USING_P (in OVERLOAD)
     449                 :            :       IMPLICIT_CONV_EXPR_NONTYPE_ARG (in IMPLICIT_CONV_EXPR)
     450                 :            :    2: IDENTIFIER_KIND_BIT_2 (in IDENTIFIER_NODE)
     451                 :            :       ICS_THIS_FLAG (in _CONV)
     452                 :            :       DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (in VAR_DECL)
     453                 :            :       STATEMENT_LIST_TRY_BLOCK (in STATEMENT_LIST)
     454                 :            :       TYPENAME_IS_RESOLVING_P (in TYPE_NAME_TYPE)
     455                 :            :       TARGET_EXPR_DIRECT_INIT_P (in TARGET_EXPR)
     456                 :            :       FNDECL_USED_AUTO (in FUNCTION_DECL)
     457                 :            :       DECLTYPE_FOR_LAMBDA_PROXY (in DECLTYPE_TYPE)
     458                 :            :       REF_PARENTHESIZED_P (in COMPONENT_REF, INDIRECT_REF, SCOPE_REF, VIEW_CONVERT_EXPR)
     459                 :            :       AGGR_INIT_ZERO_FIRST (in AGGR_INIT_EXPR)
     460                 :            :       CONSTRUCTOR_MUTABLE_POISON (in CONSTRUCTOR)
     461                 :            :       OVL_HIDDEN_P (in OVERLOAD)
     462                 :            :       SWITCH_STMT_NO_BREAK_P (in SWITCH_STMT)
     463                 :            :       LAMBDA_EXPR_CAPTURE_OPTIMIZED (in LAMBDA_EXPR)
     464                 :            :       IMPLICIT_CONV_EXPR_BRACED_INIT (in IMPLICIT_CONV_EXPR)
     465                 :            :       TINFO_VAR_DECLARED_CONSTINIT (in TEMPLATE_INFO)
     466                 :            :       CALL_FROM_NEW_OR_DELETE_P (in CALL_EXPR)
     467                 :            :    3: (TREE_REFERENCE_EXPR) (in NON_LVALUE_EXPR) (commented-out).
     468                 :            :       ICS_BAD_FLAG (in _CONV)
     469                 :            :       FN_TRY_BLOCK_P (in TRY_BLOCK)
     470                 :            :       BIND_EXPR_BODY_BLOCK (in BIND_EXPR)
     471                 :            :       CALL_EXPR_ORDERED_ARGS (in CALL_EXPR, AGGR_INIT_EXPR)
     472                 :            :       DECLTYPE_FOR_REF_CAPTURE (in DECLTYPE_TYPE)
     473                 :            :       CONSTRUCTOR_C99_COMPOUND_LITERAL (in CONSTRUCTOR)
     474                 :            :       OVL_NESTED_P (in OVERLOAD)
     475                 :            :       LAMBDA_EXPR_INSTANTIATED (in LAMBDA_EXPR)
     476                 :            :       Reserved for DECL_MODULE_EXPORT (in DECL_)
     477                 :            :    4: IDENTIFIER_MARKED (IDENTIFIER_NODEs)
     478                 :            :       TREE_HAS_CONSTRUCTOR (in INDIRECT_REF, SAVE_EXPR, CONSTRUCTOR,
     479                 :            :           CALL_EXPR, or FIELD_DECL).
     480                 :            :       DECL_TINFO_P (in VAR_DECL)
     481                 :            :       FUNCTION_REF_QUALIFIED (in FUNCTION_TYPE, METHOD_TYPE)
     482                 :            :       OVL_LOOKUP_P (in OVERLOAD)
     483                 :            :       LOOKUP_FOUND_P (in RECORD_TYPE, UNION_TYPE, NAMESPACE_DECL)
     484                 :            :    5: IDENTIFIER_VIRTUAL_P (in IDENTIFIER_NODE)
     485                 :            :       FUNCTION_RVALUE_QUALIFIED (in FUNCTION_TYPE, METHOD_TYPE)
     486                 :            :       CALL_EXPR_REVERSE_ARGS (in CALL_EXPR, AGGR_INIT_EXPR)
     487                 :            :       CONSTRUCTOR_PLACEHOLDER_BOUNDARY (in CONSTRUCTOR)
     488                 :            :    6: TYPE_MARKED_P (in _TYPE)
     489                 :            :       DECL_NON_TRIVIALLY_INITIALIZED_P (in VAR_DECL)
     490                 :            :       RANGE_FOR_IVDEP (in RANGE_FOR_STMT)
     491                 :            :       CALL_EXPR_OPERATOR_SYNTAX (in CALL_EXPR, AGGR_INIT_EXPR)
     492                 :            :       CONSTRUCTOR_IS_DESIGNATED_INIT (in CONSTRUCTOR)
     493                 :            : 
     494                 :            :    Usage of TYPE_LANG_FLAG_?:
     495                 :            :    0: TYPE_DEPENDENT_P
     496                 :            :    1: TYPE_HAS_USER_CONSTRUCTOR.
     497                 :            :    2: TYPE_HAS_LATE_RETURN_TYPE (in FUNCTION_TYPE, METHOD_TYPE)
     498                 :            :       TYPE_PTRMEMFUNC_FLAG (in RECORD_TYPE)
     499                 :            :    4: TYPE_HAS_NONTRIVIAL_DESTRUCTOR
     500                 :            :    5: CLASS_TYPE_P (in RECORD_TYPE and UNION_TYPE)
     501                 :            :       ENUM_FIXED_UNDERLYING_TYPE_P (in ENUMERAL_TYPE)
     502                 :            :       AUTO_IS_DECLTYPE (in TEMPLATE_TYPE_PARM)
     503                 :            :    6: TYPE_DEPENDENT_P_VALID
     504                 :            : 
     505                 :            :    Usage of DECL_LANG_FLAG_?:
     506                 :            :    0: DECL_TEMPLATE_PARM_P (in PARM_DECL, CONST_DECL, TYPE_DECL, or TEMPLATE_DECL)
     507                 :            :       DECL_LOCAL_FUNCTION_P (in FUNCTION_DECL)
     508                 :            :       DECL_MUTABLE_P (in FIELD_DECL)
     509                 :            :       DECL_DEPENDENT_P (in USING_DECL)
     510                 :            :       LABEL_DECL_BREAK (in LABEL_DECL)
     511                 :            :    1: C_TYPEDEF_EXPLICITLY_SIGNED (in TYPE_DECL).
     512                 :            :       DECL_TEMPLATE_INSTANTIATED (in a VAR_DECL or a FUNCTION_DECL)
     513                 :            :       DECL_MEMBER_TEMPLATE_P (in TEMPLATE_DECL)
     514                 :            :       USING_DECL_TYPENAME_P (in USING_DECL)
     515                 :            :       DECL_VLA_CAPTURE_P (in FIELD_DECL)
     516                 :            :       DECL_ARRAY_PARAMETER_P (in PARM_DECL)
     517                 :            :       LABEL_DECL_CONTINUE (in LABEL_DECL)
     518                 :            :    2: DECL_THIS_EXTERN (in VAR_DECL or FUNCTION_DECL).
     519                 :            :       DECL_IMPLICIT_TYPEDEF_P (in a TYPE_DECL)
     520                 :            :       DECL_CONSTRAINT_VAR_P (in a PARM_DECL)
     521                 :            :       TEMPLATE_DECL_COMPLEX_ALIAS_P (in TEMPLATE_DECL)
     522                 :            :       DECL_INSTANTIATING_NSDMI_P (in a FIELD_DECL)
     523                 :            :       LABEL_DECL_CDTOR (in LABEL_DECL)
     524                 :            :    3: DECL_IN_AGGR_P.
     525                 :            :    4: DECL_C_BIT_FIELD (in a FIELD_DECL)
     526                 :            :       DECL_ANON_UNION_VAR_P (in a VAR_DECL)
     527                 :            :       DECL_SELF_REFERENCE_P (in a TYPE_DECL)
     528                 :            :       DECL_INVALID_OVERRIDER_P (in a FUNCTION_DECL)
     529                 :            :    5: DECL_INTERFACE_KNOWN.
     530                 :            :    6: DECL_THIS_STATIC (in VAR_DECL or FUNCTION_DECL).
     531                 :            :       DECL_FIELD_IS_BASE (in FIELD_DECL)
     532                 :            :       TYPE_DECL_ALIAS_P (in TYPE_DECL)
     533                 :            :    7: DECL_THUNK_P (in a member FUNCTION_DECL)
     534                 :            :       DECL_NORMAL_CAPTURE_P (in FIELD_DECL)
     535                 :            :    8: DECL_DECLARED_CONSTEXPR_P (in VAR_DECL, FUNCTION_DECL)
     536                 :            : 
     537                 :            :    Usage of language-independent fields in a language-dependent manner:
     538                 :            : 
     539                 :            :    TYPE_ALIAS_SET
     540                 :            :      This field is used by TYPENAME_TYPEs, TEMPLATE_TYPE_PARMs, and so
     541                 :            :      forth as a substitute for the mark bits provided in `lang_type'.
     542                 :            :      At present, only the six low-order bits are used.
     543                 :            : 
     544                 :            :    TYPE_LANG_SLOT_1
     545                 :            :      For a FUNCTION_TYPE or METHOD_TYPE, this is TYPE_RAISES_EXCEPTIONS.
     546                 :            :      For a POINTER_TYPE (to a METHOD_TYPE), this is TYPE_PTRMEMFUNC_TYPE.
     547                 :            :      For an ENUMERAL_TYPE, BOUND_TEMPLATE_TEMPLATE_PARM_TYPE,
     548                 :            :      RECORD_TYPE or UNION_TYPE this is TYPE_TEMPLATE_INFO,
     549                 :            : 
     550                 :            :   BINFO_VIRTUALS
     551                 :            :      For a binfo, this is a TREE_LIST.  There is an entry for each
     552                 :            :      virtual function declared either in BINFO or its direct and
     553                 :            :      indirect primary bases.
     554                 :            : 
     555                 :            :      The BV_DELTA of each node gives the amount by which to adjust the
     556                 :            :      `this' pointer when calling the function.  If the method is an
     557                 :            :      overridden version of a base class method, then it is assumed
     558                 :            :      that, prior to adjustment, the this pointer points to an object
     559                 :            :      of the base class.
     560                 :            : 
     561                 :            :      The BV_VCALL_INDEX of each node, if non-NULL, gives the vtable
     562                 :            :      index of the vcall offset for this entry.
     563                 :            : 
     564                 :            :      The BV_FN is the declaration for the virtual function itself.
     565                 :            : 
     566                 :            :      If BV_LOST_PRIMARY is set, it means that this entry is for a lost
     567                 :            :      primary virtual base and can be left null in the vtable.
     568                 :            : 
     569                 :            :    BINFO_VTABLE
     570                 :            :      This is an expression with POINTER_TYPE that gives the value
     571                 :            :      to which the vptr should be initialized.  Use get_vtbl_decl_for_binfo
     572                 :            :      to extract the VAR_DECL for the complete vtable.
     573                 :            : 
     574                 :            :    DECL_VINDEX
     575                 :            :      This field is NULL for a non-virtual function.  For a virtual
     576                 :            :      function, it is eventually set to an INTEGER_CST indicating the
     577                 :            :      index in the vtable at which this function can be found.  When
     578                 :            :      a virtual function is declared, but before it is known what
     579                 :            :      function is overridden, this field is the error_mark_node.
     580                 :            : 
     581                 :            :      Temporarily, it may be set to a TREE_LIST whose TREE_VALUE is
     582                 :            :      the virtual function this one overrides, and whose TREE_CHAIN is
     583                 :            :      the old DECL_VINDEX.  */
     584                 :            : 
     585                 :            : /* Language-specific tree checkers.  */
     586                 :            : 
     587                 :            : #define VAR_OR_FUNCTION_DECL_CHECK(NODE) \
     588                 :            :   TREE_CHECK2(NODE,VAR_DECL,FUNCTION_DECL)
     589                 :            : 
     590                 :            : #define TYPE_FUNCTION_OR_TEMPLATE_DECL_CHECK(NODE) \
     591                 :            :   TREE_CHECK3(NODE,TYPE_DECL,TEMPLATE_DECL,FUNCTION_DECL)
     592                 :            : 
     593                 :            : #define TYPE_FUNCTION_OR_TEMPLATE_DECL_P(NODE) \
     594                 :            :   (TREE_CODE (NODE) == TYPE_DECL || TREE_CODE (NODE) == TEMPLATE_DECL \
     595                 :            :    || TREE_CODE (NODE) == FUNCTION_DECL)
     596                 :            : 
     597                 :            : #define VAR_FUNCTION_OR_PARM_DECL_CHECK(NODE) \
     598                 :            :   TREE_CHECK3(NODE,VAR_DECL,FUNCTION_DECL,PARM_DECL)
     599                 :            : 
     600                 :            : #define VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK(NODE) \
     601                 :            :   TREE_CHECK4(NODE,VAR_DECL,FUNCTION_DECL,TYPE_DECL,TEMPLATE_DECL)
     602                 :            : 
     603                 :            : #define VAR_TEMPL_TYPE_FIELD_OR_FUNCTION_DECL_CHECK(NODE) \
     604                 :            :   TREE_CHECK5(NODE,VAR_DECL,FIELD_DECL,FUNCTION_DECL,TYPE_DECL,TEMPLATE_DECL)
     605                 :            : 
     606                 :            : #define BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK(NODE) \
     607                 :            :   TREE_CHECK(NODE,BOUND_TEMPLATE_TEMPLATE_PARM)
     608                 :            : 
     609                 :            : #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
     610                 :            : 
     611                 :            : /* Returns t iff the node can have a TEMPLATE_INFO field.  */
     612                 :            : 
     613                 :            : inline tree
     614                 : 2206890088 : template_info_decl_check (const_tree t, const char* f, int l, const char* fn)
     615                 :            : {
     616                 : 2206890088 :   switch (TREE_CODE (t))
     617                 :            :     {
     618                 : 2206890088 :     case VAR_DECL:
     619                 : 2206890088 :     case FUNCTION_DECL:
     620                 : 2206890088 :     case FIELD_DECL:
     621                 : 2206890088 :     case TYPE_DECL:
     622                 : 2206890088 :     case CONCEPT_DECL:
     623                 : 2206890088 :     case TEMPLATE_DECL:
     624                 : 2206890088 :       return const_cast<tree>(t);
     625                 :          0 :     default:
     626                 :          0 :       break;
     627                 :            :     }
     628                 :          0 :   tree_check_failed (t, f, l, fn,
     629                 :            :                      VAR_DECL, FUNCTION_DECL, FIELD_DECL, TYPE_DECL,
     630                 :            :                      CONCEPT_DECL, TEMPLATE_DECL, 0);
     631                 :            :   gcc_unreachable ();
     632                 :            : }
     633                 :            : 
     634                 :            : #define TEMPLATE_INFO_DECL_CHECK(NODE) \
     635                 :            :   template_info_decl_check ((NODE), __FILE__, __LINE__, __FUNCTION__)
     636                 :            : 
     637                 :            : #define THUNK_FUNCTION_CHECK(NODE) __extension__                        \
     638                 :            : ({  __typeof (NODE) const __t = (NODE);                                 \
     639                 :            :     if (TREE_CODE (__t) != FUNCTION_DECL || !__t->decl_common.lang_specific \
     640                 :            :         || !__t->decl_common.lang_specific->u.fn.thunk_p)         \
     641                 :            :       tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, 0);     \
     642                 :            :      __t; })
     643                 :            : 
     644                 :            : #else /* ENABLE_TREE_CHECKING */
     645                 :            : 
     646                 :            : #define TEMPLATE_INFO_DECL_CHECK(NODE) (NODE)
     647                 :            : #define THUNK_FUNCTION_CHECK(NODE) (NODE)
     648                 :            : 
     649                 :            : #endif /* ENABLE_TREE_CHECKING */
     650                 :            : 
     651                 :            : /* Language-dependent contents of an identifier.  */
     652                 :            : 
     653                 :            : struct GTY(()) lang_identifier {
     654                 :            :   struct c_common_identifier c_common;
     655                 :            :   cxx_binding *bindings;
     656                 :            : };
     657                 :            : 
     658                 :            : /* Return a typed pointer version of T if it designates a
     659                 :            :    C++ front-end identifier.  */
     660                 :            : inline lang_identifier*
     661                 : 1834433028 : identifier_p (tree t)
     662                 :            : {
     663                 : 1834215692 :   if (TREE_CODE (t) == IDENTIFIER_NODE)
     664                 : 1009314511 :     return (lang_identifier*) t;
     665                 :            :   return NULL;
     666                 :            : }
     667                 :            : 
     668                 :            : #define LANG_IDENTIFIER_CAST(NODE) \
     669                 :            :         ((struct lang_identifier*)IDENTIFIER_NODE_CHECK (NODE))
     670                 :            : 
     671                 :            : struct GTY(()) template_parm_index {
     672                 :            :   struct tree_common common;
     673                 :            :   int index;
     674                 :            :   int level;
     675                 :            :   int orig_level;
     676                 :            :   tree decl;
     677                 :            : };
     678                 :            : 
     679                 :            : struct GTY(()) ptrmem_cst {
     680                 :            :   struct tree_common common;
     681                 :            :   tree member;
     682                 :            : };
     683                 :            : typedef struct ptrmem_cst * ptrmem_cst_t;
     684                 :            : 
     685                 :            : #define CLEANUP_P(NODE)         TREE_LANG_FLAG_0 (TRY_BLOCK_CHECK (NODE))
     686                 :            : 
     687                 :            : #define BIND_EXPR_TRY_BLOCK(NODE) \
     688                 :            :   TREE_LANG_FLAG_0 (BIND_EXPR_CHECK (NODE))
     689                 :            : 
     690                 :            : /* Used to mark the block around the member initializers and cleanups.  */
     691                 :            : #define BIND_EXPR_BODY_BLOCK(NODE) \
     692                 :            :   TREE_LANG_FLAG_3 (BIND_EXPR_CHECK (NODE))
     693                 :            : #define FUNCTION_NEEDS_BODY_BLOCK(NODE) \
     694                 :            :   (DECL_CONSTRUCTOR_P (NODE) || DECL_DESTRUCTOR_P (NODE) \
     695                 :            :    || LAMBDA_FUNCTION_P (NODE))
     696                 :            : 
     697                 :            : #define STATEMENT_LIST_NO_SCOPE(NODE) \
     698                 :            :   TREE_LANG_FLAG_0 (STATEMENT_LIST_CHECK (NODE))
     699                 :            : #define STATEMENT_LIST_TRY_BLOCK(NODE) \
     700                 :            :   TREE_LANG_FLAG_2 (STATEMENT_LIST_CHECK (NODE))
     701                 :            : 
     702                 :            : /* Mark the outer curly brace BLOCK.  */
     703                 :            : #define BLOCK_OUTER_CURLY_BRACE_P(NODE) TREE_LANG_FLAG_0 (BLOCK_CHECK (NODE))
     704                 :            : 
     705                 :            : /* Nonzero if this statement should be considered a full-expression,
     706                 :            :    i.e., if temporaries created during this statement should have
     707                 :            :    their destructors run at the end of this statement.  */
     708                 :            : #define STMT_IS_FULL_EXPR_P(NODE) TREE_LANG_FLAG_1 ((NODE))
     709                 :            : 
     710                 :            : /* Marks the result of a statement expression.  */
     711                 :            : #define EXPR_STMT_STMT_EXPR_RESULT(NODE) \
     712                 :            :   TREE_LANG_FLAG_0 (EXPR_STMT_CHECK (NODE))
     713                 :            : 
     714                 :            : /* Nonzero if this statement-expression does not have an associated scope.  */
     715                 :            : #define STMT_EXPR_NO_SCOPE(NODE) \
     716                 :            :    TREE_LANG_FLAG_0 (STMT_EXPR_CHECK (NODE))
     717                 :            : 
     718                 :            : #define COND_EXPR_IS_VEC_DELETE(NODE) \
     719                 :            :   TREE_LANG_FLAG_0 (COND_EXPR_CHECK (NODE))
     720                 :            : 
     721                 :            : /* Nonzero if this NOP_EXPR is a reinterpret_cast.  Such conversions
     722                 :            :    are not constexprs.  Other NOP_EXPRs are.  */
     723                 :            : #define REINTERPRET_CAST_P(NODE)                \
     724                 :            :   TREE_LANG_FLAG_0 (NOP_EXPR_CHECK (NODE))
     725                 :            : 
     726                 :            : /* Returns nonzero iff TYPE1 and TYPE2 are the same type, in the usual
     727                 :            :    sense of `same'.  */
     728                 :            : #define same_type_p(TYPE1, TYPE2) \
     729                 :            :   comptypes ((TYPE1), (TYPE2), COMPARE_STRICT)
     730                 :            : 
     731                 :            : /* Returns nonzero iff NODE is a declaration for the global function
     732                 :            :    `main'.  */
     733                 :            : #define DECL_MAIN_P(NODE)                               \
     734                 :            :    (DECL_EXTERN_C_FUNCTION_P (NODE)                     \
     735                 :            :     && DECL_NAME (NODE) != NULL_TREE                    \
     736                 :            :     && MAIN_NAME_P (DECL_NAME (NODE))                   \
     737                 :            :     && flag_hosted)
     738                 :            : 
     739                 :            : /* Lookup walker marking.  */
     740                 :            : #define LOOKUP_SEEN_P(NODE) TREE_VISITED(NODE)
     741                 :            : #define LOOKUP_FOUND_P(NODE) \
     742                 :            :   TREE_LANG_FLAG_4 (TREE_CHECK3(NODE,RECORD_TYPE,UNION_TYPE,NAMESPACE_DECL))
     743                 :            : 
     744                 :            : /* These two accessors should only be used by OVL manipulators.
     745                 :            :    Other users should use iterators and convenience functions.  */
     746                 :            : #define OVL_FUNCTION(NODE) \
     747                 :            :   (((struct tree_overload*)OVERLOAD_CHECK (NODE))->function)
     748                 :            : #define OVL_CHAIN(NODE) \
     749                 :            :   (((struct tree_overload*)OVERLOAD_CHECK (NODE))->common.chain)
     750                 :            : 
     751                 :            : /* If set, this or a subsequent overload contains decls that need deduping.  */
     752                 :            : #define OVL_DEDUP_P(NODE)       TREE_LANG_FLAG_0 (OVERLOAD_CHECK (NODE))
     753                 :            : /* If set, this was imported in a using declaration.   */
     754                 :            : #define OVL_USING_P(NODE)       TREE_LANG_FLAG_1 (OVERLOAD_CHECK (NODE))
     755                 :            : /* If set, this overload is a hidden decl.  */
     756                 :            : #define OVL_HIDDEN_P(NODE)      TREE_LANG_FLAG_2 (OVERLOAD_CHECK (NODE))
     757                 :            : /* If set, this overload contains a nested overload.  */
     758                 :            : #define OVL_NESTED_P(NODE)      TREE_LANG_FLAG_3 (OVERLOAD_CHECK (NODE))
     759                 :            : /* If set, this overload was constructed during lookup.  */
     760                 :            : #define OVL_LOOKUP_P(NODE)      TREE_LANG_FLAG_4 (OVERLOAD_CHECK (NODE))
     761                 :            : 
     762                 :            : /* The first decl of an overload.  */
     763                 :            : #define OVL_FIRST(NODE) ovl_first (NODE)
     764                 :            : /* The name of the overload set.  */
     765                 :            : #define OVL_NAME(NODE) DECL_NAME (OVL_FIRST (NODE))
     766                 :            : 
     767                 :            : /* Whether this is a set of overloaded functions.  TEMPLATE_DECLS are
     768                 :            :    always wrapped in an OVERLOAD, so we don't need to check them
     769                 :            :    here.  */
     770                 :            : #define OVL_P(NODE) \
     771                 :            :   (TREE_CODE (NODE) == FUNCTION_DECL || TREE_CODE (NODE) == OVERLOAD)
     772                 :            : /* Whether this is a single member overload.  */
     773                 :            : #define OVL_SINGLE_P(NODE) \
     774                 :            :   (TREE_CODE (NODE) != OVERLOAD || !OVL_CHAIN (NODE))
     775                 :            : 
     776                 :            : /* OVL_HIDDEN_P nodes come before other nodes.  */
     777                 :            : 
     778                 :            : struct GTY(()) tree_overload {
     779                 :            :   struct tree_common common;
     780                 :            :   tree function;
     781                 :            : };
     782                 :            : 
     783                 :            : /* Iterator for a 1 dimensional overload.  Permits iterating over the
     784                 :            :    outer level of a 2-d overload when explicitly enabled.  */
     785                 :            : 
     786                 :            : class ovl_iterator
     787                 :            : {
     788                 :            :   tree ovl;
     789                 :            :   const bool allow_inner; /* Only used when checking.  */
     790                 :            : 
     791                 :            :  public:
     792                 :  498602048 :   explicit ovl_iterator (tree o, bool allow = false)
     793                 :  498602048 :     : ovl (o), allow_inner (allow)
     794                 :            :   {
     795                 :  401158605 :   }
     796                 :            : 
     797                 :            :  private:
     798                 :            :   /* Do not duplicate.  */
     799                 :            :   ovl_iterator &operator= (const ovl_iterator &);
     800                 :            :   ovl_iterator (const ovl_iterator &);
     801                 :            : 
     802                 :            :  public:
     803                 :  993735092 :   operator bool () const
     804                 :            :   {
     805                 :  797621427 :     return ovl;
     806                 :            :   }
     807                 :  327083006 :   ovl_iterator &operator++ ()
     808                 :            :   {
     809                 :  288444483 :     ovl = TREE_CODE (ovl) != OVERLOAD ? NULL_TREE : OVL_CHAIN (ovl);
     810                 :  141544270 :     return *this;
     811                 :            :   }
     812                 :  365109526 :   tree operator* () const
     813                 :            :   {
     814                 :  365109526 :     tree fn = TREE_CODE (ovl) != OVERLOAD ? ovl : OVL_FUNCTION (ovl);
     815                 :            : 
     816                 :            :     /* Check this is not an unexpected 2-dimensional overload.  */
     817                 :  365109526 :     gcc_checking_assert (allow_inner || TREE_CODE (fn) != OVERLOAD);
     818                 :            : 
     819                 :  365109526 :     return fn;
     820                 :            :   }
     821                 :            : 
     822                 :            :  public:
     823                 :            :   /* Whether this overload was introduced by a using decl.  */
     824                 :   70739540 :   bool using_p () const
     825                 :            :   {
     826                 :   70739540 :     return (TREE_CODE (ovl) == USING_DECL
     827                 :   70739540 :             || (TREE_CODE (ovl) == OVERLOAD && OVL_USING_P (ovl)));
     828                 :            :   }
     829                 :     994467 :   bool hidden_p () const
     830                 :            :   {
     831                 :     994467 :     return TREE_CODE (ovl) == OVERLOAD && OVL_HIDDEN_P (ovl);
     832                 :            :   }
     833                 :            : 
     834                 :            :  public:
     835                 :       3904 :   tree remove_node (tree head)
     836                 :            :   {
     837                 :       3904 :     return remove_node (head, ovl);
     838                 :            :   }
     839                 :     328757 :   tree reveal_node (tree head)
     840                 :            :   {
     841                 :     328757 :     return reveal_node (head, ovl);
     842                 :            :   }
     843                 :            : 
     844                 :            :  protected:
     845                 :            :   /* If we have a nested overload, point at the inner overload and
     846                 :            :      return the next link on the outer one.  */
     847                 :  287910958 :   tree maybe_push ()
     848                 :            :   {
     849                 :  287910958 :     tree r = NULL_TREE;
     850                 :            : 
     851                 :  201752914 :     if (ovl && TREE_CODE (ovl) == OVERLOAD && OVL_NESTED_P (ovl))
     852                 :            :       {
     853                 :     608189 :         r = OVL_CHAIN (ovl);
     854                 :     608189 :         ovl = OVL_FUNCTION (ovl);
     855                 :            :       }
     856                 :  287910958 :     return r;
     857                 :            :   }
     858                 :            :   /* Restore an outer nested overload.  */
     859                 :     532742 :   void pop (tree outer)
     860                 :            :   {
     861                 :     532742 :     gcc_checking_assert (!ovl);
     862                 :     532742 :     ovl = outer;
     863                 :            :   }
     864                 :            : 
     865                 :            :  private:
     866                 :            :   /* We make these static functions to avoid the address of the
     867                 :            :      iterator escaping the local context.  */
     868                 :            :   static tree remove_node (tree head, tree node);
     869                 :            :   static tree reveal_node (tree ovl, tree node);
     870                 :            : };
     871                 :            : 
     872                 :            : /* Iterator over a (potentially) 2 dimensional overload, which is
     873                 :            :    produced by name lookup.  */
     874                 :            : 
     875                 :            : class lkp_iterator : public ovl_iterator
     876                 :            : {
     877                 :            :   typedef ovl_iterator parent;
     878                 :            : 
     879                 :            :   tree outer;
     880                 :            : 
     881                 :            :  public:
     882                 :   67860148 :   explicit lkp_iterator (tree o)
     883                 :   97443334 :     : parent (o, true), outer (maybe_push ())
     884                 :            :   {
     885                 :   97132134 :   }
     886                 :            : 
     887                 :            :  public:
     888                 :  195802165 :   lkp_iterator &operator++ ()
     889                 :            :   {
     890                 :  195802165 :     bool repush = !outer;
     891                 :            : 
     892                 :  352965453 :     if (!parent::operator++ () && !repush)
     893                 :            :       {
     894                 :     532742 :         pop (outer);
     895                 :     532742 :         repush = true;
     896                 :            :       }
     897                 :            : 
     898                 :  195802165 :     if (repush)
     899                 :  311263072 :       outer = maybe_push ();
     900                 :            : 
     901                 :  195802165 :     return *this;
     902                 :            :   }
     903                 :            : };
     904                 :            : 
     905                 :            : /* hash traits for declarations.  Hashes potential overload sets via
     906                 :            :    DECL_NAME.  */
     907                 :            : 
     908                 :            : struct named_decl_hash : ggc_remove <tree>
     909                 :            : {
     910                 :            :   typedef tree value_type; /* A DECL or OVERLOAD  */
     911                 :            :   typedef tree compare_type; /* An identifier.  */
     912                 :            : 
     913                 :            :   inline static hashval_t hash (const value_type decl);
     914                 :            :   inline static bool equal (const value_type existing, compare_type candidate);
     915                 :            : 
     916                 :            :   static const bool empty_zero_p = true;
     917                 :            :   static inline void mark_empty (value_type &p) {p = NULL_TREE;}
     918                 : 7107630332 :   static inline bool is_empty (value_type p) {return !p;}
     919                 :            : 
     920                 :            :   /* Nothing is deletable.  Everything is insertable.  */
     921                 : 2790586632 :   static bool is_deleted (value_type) { return false; }
     922                 :            :   static void mark_deleted (value_type) { gcc_unreachable (); }
     923                 :            : };
     924                 :            : 
     925                 :            : /* Simplified unique_ptr clone to release a tree vec on exit.  */
     926                 :            : 
     927                 :            : class releasing_vec
     928                 :            : {
     929                 :            : public:
     930                 :            :   typedef vec<tree, va_gc> vec_t;
     931                 :            : 
     932                 :    2671234 :   releasing_vec (vec_t *v): v(v) { }
     933                 :   33373839 :   releasing_vec (): v(make_tree_vector ()) { }
     934                 :            : 
     935                 :            :   /* Copy ops are deliberately declared but not defined,
     936                 :            :      copies must always be elided.  */
     937                 :            :   releasing_vec (const releasing_vec &);
     938                 :            :   releasing_vec &operator= (const releasing_vec &);
     939                 :            : 
     940                 :     326610 :   vec_t &operator* () const { return *v; }
     941                 :   10980609 :   vec_t *operator-> () const { return v; }
     942                 :            :   vec_t *get() const { return v; }
     943                 :    1849625 :   operator vec_t *() const { return v; }
     944                 :   23958898 :   vec_t ** operator& () { return &v; }
     945                 :            : 
     946                 :            :   /* Breaks pointer/value consistency for convenience.  */
     947                 :         58 :   tree& operator[] (unsigned i) const { return (*v)[i]; }
     948                 :            : 
     949                 :   32272328 :   ~releasing_vec() { release_tree_vector (v); }
     950                 :            : private:
     951                 :            :   vec_t *v;
     952                 :            : };
     953                 :            : /* Forwarding functions for vec_safe_* that might reallocate.  */
     954                 :   13839206 : inline tree* vec_safe_push (releasing_vec& r, const tree &t CXX_MEM_STAT_INFO)
     955                 :   13839206 : { return vec_safe_push (*&r, t PASS_MEM_STAT); }
     956                 :    2630047 : inline bool vec_safe_reserve (releasing_vec& r, unsigned n, bool e = false CXX_MEM_STAT_INFO)
     957                 :    2630047 : { return vec_safe_reserve (*&r, n, e PASS_MEM_STAT); }
     958                 :         81 : inline unsigned vec_safe_length (releasing_vec &r)
     959                 :         81 : { return r->length(); }
     960                 :         16 : inline void vec_safe_splice (releasing_vec &r, vec<tree, va_gc> *p CXX_MEM_STAT_INFO)
     961                 :         16 : { vec_safe_splice (*&r, p PASS_MEM_STAT); }
     962                 :            : void release_tree_vector (releasing_vec &); // cause link error
     963                 :            : 
     964                 :            : struct GTY(()) tree_template_decl {
     965                 :            :   struct tree_decl_common common;
     966                 :            :   tree arguments;
     967                 :            :   tree result;
     968                 :            : };
     969                 :            : 
     970                 :            : /* Returns true iff NODE is a BASELINK.  */
     971                 :            : #define BASELINK_P(NODE) \
     972                 :            :   (TREE_CODE (NODE) == BASELINK)
     973                 :            : /* The BINFO indicating the base in which lookup found the
     974                 :            :    BASELINK_FUNCTIONS.  */
     975                 :            : #define BASELINK_BINFO(NODE) \
     976                 :            :   (((struct tree_baselink*) BASELINK_CHECK (NODE))->binfo)
     977                 :            : /* The functions referred to by the BASELINK; either a FUNCTION_DECL,
     978                 :            :    a TEMPLATE_DECL, an OVERLOAD, or a TEMPLATE_ID_EXPR.  */
     979                 :            : #define BASELINK_FUNCTIONS(NODE) \
     980                 :            :   (((struct tree_baselink*) BASELINK_CHECK (NODE))->functions)
     981                 :            : /* If T is a BASELINK, grab the functions, otherwise just T, which is
     982                 :            :    expected to already be a (list of) functions.  */
     983                 :            : #define MAYBE_BASELINK_FUNCTIONS(T) \
     984                 :            :   (BASELINK_P (T) ? BASELINK_FUNCTIONS (T) : T)
     985                 :            : /* The BINFO in which the search for the functions indicated by this baselink
     986                 :            :    began.  This base is used to determine the accessibility of functions
     987                 :            :    selected by overload resolution.  */
     988                 :            : #define BASELINK_ACCESS_BINFO(NODE) \
     989                 :            :   (((struct tree_baselink*) BASELINK_CHECK (NODE))->access_binfo)
     990                 :            : /* For a type-conversion operator, the BASELINK_OPTYPE indicates the type
     991                 :            :    to which the conversion should occur.  This value is important if
     992                 :            :    the BASELINK_FUNCTIONS include a template conversion operator --
     993                 :            :    the BASELINK_OPTYPE can be used to determine what type the user
     994                 :            :    requested.  */
     995                 :            : #define BASELINK_OPTYPE(NODE) \
     996                 :            :   (TREE_CHAIN (BASELINK_CHECK (NODE)))
     997                 :            : /* Nonzero if this baselink was from a qualified lookup.  */
     998                 :            : #define BASELINK_QUALIFIED_P(NODE) \
     999                 :            :   TREE_LANG_FLAG_0 (BASELINK_CHECK (NODE))
    1000                 :            : 
    1001                 :            : struct GTY(()) tree_baselink {
    1002                 :            :   struct tree_common common;
    1003                 :            :   tree binfo;
    1004                 :            :   tree functions;
    1005                 :            :   tree access_binfo;
    1006                 :            : };
    1007                 :            : 
    1008                 :            : /* The different kinds of ids that we encounter.  */
    1009                 :            : 
    1010                 :            : enum cp_id_kind
    1011                 :            : {
    1012                 :            :   /* Not an id at all.  */
    1013                 :            :   CP_ID_KIND_NONE,
    1014                 :            :   /* An unqualified-id that is not a template-id.  */
    1015                 :            :   CP_ID_KIND_UNQUALIFIED,
    1016                 :            :   /* An unqualified-id that is a dependent name.  */
    1017                 :            :   CP_ID_KIND_UNQUALIFIED_DEPENDENT,
    1018                 :            :   /* An unqualified template-id.  */
    1019                 :            :   CP_ID_KIND_TEMPLATE_ID,
    1020                 :            :   /* A qualified-id.  */
    1021                 :            :   CP_ID_KIND_QUALIFIED
    1022                 :            : };
    1023                 :            : 
    1024                 :            : 
    1025                 :            : /* The various kinds of C++0x warnings we encounter. */
    1026                 :            : 
    1027                 :            : enum cpp0x_warn_str
    1028                 :            : {
    1029                 :            :   /* extended initializer lists */
    1030                 :            :   CPP0X_INITIALIZER_LISTS,
    1031                 :            :   /* explicit conversion operators */
    1032                 :            :   CPP0X_EXPLICIT_CONVERSION,
    1033                 :            :   /* variadic templates */
    1034                 :            :   CPP0X_VARIADIC_TEMPLATES,
    1035                 :            :   /* lambda expressions */
    1036                 :            :   CPP0X_LAMBDA_EXPR,
    1037                 :            :   /* C++0x auto */
    1038                 :            :   CPP0X_AUTO,
    1039                 :            :   /* scoped enums */
    1040                 :            :   CPP0X_SCOPED_ENUMS,
    1041                 :            :   /* defaulted and deleted functions */
    1042                 :            :   CPP0X_DEFAULTED_DELETED,
    1043                 :            :   /* inline namespaces */
    1044                 :            :   CPP0X_INLINE_NAMESPACES,
    1045                 :            :   /* override controls, override/final */
    1046                 :            :   CPP0X_OVERRIDE_CONTROLS,
    1047                 :            :   /* non-static data member initializers */
    1048                 :            :   CPP0X_NSDMI,
    1049                 :            :   /* user defined literals */
    1050                 :            :   CPP0X_USER_DEFINED_LITERALS,
    1051                 :            :   /* delegating constructors */
    1052                 :            :   CPP0X_DELEGATING_CTORS,
    1053                 :            :   /* inheriting constructors */
    1054                 :            :   CPP0X_INHERITING_CTORS,
    1055                 :            :   /* C++11 attributes */
    1056                 :            :   CPP0X_ATTRIBUTES,
    1057                 :            :   /* ref-qualified member functions */
    1058                 :            :   CPP0X_REF_QUALIFIER
    1059                 :            : };
    1060                 :            : 
    1061                 :            : /* The various kinds of operation used by composite_pointer_type. */
    1062                 :            : 
    1063                 :            : enum composite_pointer_operation
    1064                 :            : {
    1065                 :            :   /* comparison */
    1066                 :            :   CPO_COMPARISON,
    1067                 :            :   /* conversion */
    1068                 :            :   CPO_CONVERSION,
    1069                 :            :   /* conditional expression */
    1070                 :            :   CPO_CONDITIONAL_EXPR
    1071                 :            : };
    1072                 :            : 
    1073                 :            : /* Possible cases of expression list used by build_x_compound_expr_from_list. */
    1074                 :            : enum expr_list_kind {
    1075                 :            :   ELK_INIT,             /* initializer */
    1076                 :            :   ELK_MEM_INIT,         /* member initializer */
    1077                 :            :   ELK_FUNC_CAST         /* functional cast */
    1078                 :            : };
    1079                 :            : 
    1080                 :            : /* Possible cases of implicit bad rhs conversions. */
    1081                 :            : enum impl_conv_rhs {
    1082                 :            :   ICR_DEFAULT_ARGUMENT, /* default argument */
    1083                 :            :   ICR_CONVERTING,       /* converting */
    1084                 :            :   ICR_INIT,             /* initialization */
    1085                 :            :   ICR_ARGPASS,          /* argument passing */
    1086                 :            :   ICR_RETURN,           /* return */
    1087                 :            :   ICR_ASSIGN            /* assignment */
    1088                 :            : };
    1089                 :            : 
    1090                 :            : /* Possible cases of implicit or explicit bad conversions to void. */
    1091                 :            : enum impl_conv_void {
    1092                 :            :   ICV_CAST,            /* (explicit) conversion to void */
    1093                 :            :   ICV_SECOND_OF_COND,  /* second operand of conditional expression */
    1094                 :            :   ICV_THIRD_OF_COND,   /* third operand of conditional expression */
    1095                 :            :   ICV_RIGHT_OF_COMMA,  /* right operand of comma operator */
    1096                 :            :   ICV_LEFT_OF_COMMA,   /* left operand of comma operator */
    1097                 :            :   ICV_STATEMENT,       /* statement */
    1098                 :            :   ICV_THIRD_IN_FOR     /* for increment expression */
    1099                 :            : };
    1100                 :            : 
    1101                 :            : /* Possible invalid uses of an abstract class that might not have a
    1102                 :            :    specific associated declaration.  */
    1103                 :            : enum GTY(()) abstract_class_use {
    1104                 :            :   ACU_UNKNOWN,                  /* unknown or decl provided */
    1105                 :            :   ACU_CAST,                     /* cast to abstract class */
    1106                 :            :   ACU_NEW,                      /* new-expression of abstract class */
    1107                 :            :   ACU_THROW,                    /* throw-expression of abstract class */
    1108                 :            :   ACU_CATCH,                    /* catch-parameter of abstract class */
    1109                 :            :   ACU_ARRAY,                    /* array of abstract class */
    1110                 :            :   ACU_RETURN,                   /* return type of abstract class */
    1111                 :            :   ACU_PARM                      /* parameter type of abstract class */
    1112                 :            : };
    1113                 :            : 
    1114                 :            : /* Macros for access to language-specific slots in an identifier.  */
    1115                 :            : 
    1116                 :            : /* The IDENTIFIER_BINDING is the innermost cxx_binding for the
    1117                 :            :     identifier.  Its PREVIOUS is the next outermost binding.  Each
    1118                 :            :     VALUE field is a DECL for the associated declaration.  Thus,
    1119                 :            :     name lookup consists simply of pulling off the node at the front
    1120                 :            :     of the list (modulo oddities for looking up the names of types,
    1121                 :            :     and such.)  You can use SCOPE field to determine the scope
    1122                 :            :     that bound the name.  */
    1123                 :            : #define IDENTIFIER_BINDING(NODE) \
    1124                 :            :   (LANG_IDENTIFIER_CAST (NODE)->bindings)
    1125                 :            : 
    1126                 :            : /* TREE_TYPE only indicates on local and class scope the current
    1127                 :            :    type. For namespace scope, the presence of a type in any namespace
    1128                 :            :    is indicated with global_type_node, and the real type behind must
    1129                 :            :    be found through lookup.  */
    1130                 :            : #define IDENTIFIER_TYPE_VALUE(NODE) identifier_type_value (NODE)
    1131                 :            : #define REAL_IDENTIFIER_TYPE_VALUE(NODE) TREE_TYPE (NODE)
    1132                 :            : #define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (TREE_TYPE (NODE) = (TYPE))
    1133                 :            : #define IDENTIFIER_HAS_TYPE_VALUE(NODE) (IDENTIFIER_TYPE_VALUE (NODE) ? 1 : 0)
    1134                 :            : 
    1135                 :            : /* Kinds of identifiers.  Values are carefully chosen.  */
    1136                 :            : enum cp_identifier_kind {
    1137                 :            :   cik_normal = 0,       /* Not a special identifier.  */
    1138                 :            :   cik_keyword = 1,      /* A keyword.  */
    1139                 :            :   cik_ctor = 2,         /* Constructor (in-chg, complete or base).  */
    1140                 :            :   cik_dtor = 3,         /* Destructor (in-chg, deleting, complete or
    1141                 :            :                            base).  */
    1142                 :            :   cik_simple_op = 4,    /* Non-assignment operator name.  */
    1143                 :            :   cik_assign_op = 5,    /* An assignment operator name.  */
    1144                 :            :   cik_conv_op = 6,      /* Conversion operator name.  */
    1145                 :            :   cik_reserved_for_udlit = 7,   /* Not yet in use  */
    1146                 :            :   cik_max
    1147                 :            : };
    1148                 :            : 
    1149                 :            : /* Kind bits.  */
    1150                 :            : #define IDENTIFIER_KIND_BIT_0(NODE) \
    1151                 :            :   TREE_LANG_FLAG_0 (IDENTIFIER_NODE_CHECK (NODE))
    1152                 :            : #define IDENTIFIER_KIND_BIT_1(NODE) \
    1153                 :            :   TREE_LANG_FLAG_1 (IDENTIFIER_NODE_CHECK (NODE))
    1154                 :            : #define IDENTIFIER_KIND_BIT_2(NODE) \
    1155                 :            :   TREE_LANG_FLAG_2 (IDENTIFIER_NODE_CHECK (NODE))
    1156                 :            : 
    1157                 :            : /* Used by various search routines.  */
    1158                 :            : #define IDENTIFIER_MARKED(NODE) \
    1159                 :            :   TREE_LANG_FLAG_4 (IDENTIFIER_NODE_CHECK (NODE))
    1160                 :            : 
    1161                 :            : /* Nonzero if this identifier is used as a virtual function name somewhere
    1162                 :            :    (optimizes searches).  */
    1163                 :            : #define IDENTIFIER_VIRTUAL_P(NODE) \
    1164                 :            :   TREE_LANG_FLAG_5 (IDENTIFIER_NODE_CHECK (NODE))
    1165                 :            : 
    1166                 :            : /* True if this identifier is a reserved word.  C_RID_CODE (node) is
    1167                 :            :    then the RID_* value of the keyword.  Value 1.  */
    1168                 :            : #define IDENTIFIER_KEYWORD_P(NODE)              \
    1169                 :            :   ((!IDENTIFIER_KIND_BIT_2 (NODE))              \
    1170                 :            :    & (!IDENTIFIER_KIND_BIT_1 (NODE))                \
    1171                 :            :    & IDENTIFIER_KIND_BIT_0 (NODE))
    1172                 :            : 
    1173                 :            : /* True if this identifier is the name of a constructor or
    1174                 :            :    destructor.  Value 2 or 3.  */
    1175                 :            : #define IDENTIFIER_CDTOR_P(NODE)                \
    1176                 :            :   ((!IDENTIFIER_KIND_BIT_2 (NODE))              \
    1177                 :            :    & IDENTIFIER_KIND_BIT_1 (NODE))
    1178                 :            : 
    1179                 :            : /* True if this identifier is the name of a constructor.  Value 2.  */
    1180                 :            : #define IDENTIFIER_CTOR_P(NODE)                 \
    1181                 :            :   (IDENTIFIER_CDTOR_P(NODE)                     \
    1182                 :            :     & (!IDENTIFIER_KIND_BIT_0 (NODE)))
    1183                 :            : 
    1184                 :            : /* True if this identifier is the name of a destructor.  Value 3.  */
    1185                 :            : #define IDENTIFIER_DTOR_P(NODE)                 \
    1186                 :            :   (IDENTIFIER_CDTOR_P(NODE)                     \
    1187                 :            :     & IDENTIFIER_KIND_BIT_0 (NODE))
    1188                 :            : 
    1189                 :            : /* True if this identifier is for any operator name (including
    1190                 :            :    conversions).  Value 4, 5, 6 or 7.  */
    1191                 :            : #define IDENTIFIER_ANY_OP_P(NODE)               \
    1192                 :            :   (IDENTIFIER_KIND_BIT_2 (NODE))
    1193                 :            : 
    1194                 :            : /* True if this identifier is for an overloaded operator. Values 4, 5.  */
    1195                 :            : #define IDENTIFIER_OVL_OP_P(NODE)               \
    1196                 :            :   (IDENTIFIER_ANY_OP_P (NODE)                   \
    1197                 :            :    & (!IDENTIFIER_KIND_BIT_1 (NODE)))
    1198                 :            : 
    1199                 :            : /* True if this identifier is for any assignment. Values 5.  */
    1200                 :            : #define IDENTIFIER_ASSIGN_OP_P(NODE)            \
    1201                 :            :   (IDENTIFIER_OVL_OP_P (NODE)                   \
    1202                 :            :    & IDENTIFIER_KIND_BIT_0 (NODE))
    1203                 :            : 
    1204                 :            : /* True if this identifier is the name of a type-conversion
    1205                 :            :    operator.  Value 7.  */
    1206                 :            : #define IDENTIFIER_CONV_OP_P(NODE)              \
    1207                 :            :   (IDENTIFIER_ANY_OP_P (NODE)                   \
    1208                 :            :    & IDENTIFIER_KIND_BIT_1 (NODE)           \
    1209                 :            :    & (!IDENTIFIER_KIND_BIT_0 (NODE)))
    1210                 :            : 
    1211                 :            : /* True if this identifier is a new or delete operator.  */
    1212                 :            : #define IDENTIFIER_NEWDEL_OP_P(NODE)            \
    1213                 :            :   (IDENTIFIER_OVL_OP_P (NODE)                   \
    1214                 :            :    && IDENTIFIER_OVL_OP_FLAGS (NODE) & OVL_OP_FLAG_ALLOC)
    1215                 :            : 
    1216                 :            : /* True if this identifier is a new operator.  */
    1217                 :            : #define IDENTIFIER_NEW_OP_P(NODE)                                       \
    1218                 :            :   (IDENTIFIER_OVL_OP_P (NODE)                                           \
    1219                 :            :    && (IDENTIFIER_OVL_OP_FLAGS (NODE)                                   \
    1220                 :            :        & (OVL_OP_FLAG_ALLOC | OVL_OP_FLAG_DELETE)) == OVL_OP_FLAG_ALLOC)
    1221                 :            : 
    1222                 :            : /* Access a C++-specific index for identifier NODE.
    1223                 :            :    Used to optimize operator mappings etc.  */
    1224                 :            : #define IDENTIFIER_CP_INDEX(NODE)               \
    1225                 :            :   (IDENTIFIER_NODE_CHECK(NODE)->base.u.bits.address_space)
    1226                 :            : 
    1227                 :            : /* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only.  */
    1228                 :            : #define C_TYPE_FIELDS_READONLY(TYPE) \
    1229                 :            :   (LANG_TYPE_CLASS_CHECK (TYPE)->fields_readonly)
    1230                 :            : 
    1231                 :            : /* The tokens stored in the unparsed operand.  */
    1232                 :            : 
    1233                 :            : #define DEFPARSE_TOKENS(NODE) \
    1234                 :            :   (((struct tree_deferred_parse *)DEFERRED_PARSE_CHECK (NODE))->tokens)
    1235                 :            : #define DEFPARSE_INSTANTIATIONS(NODE) \
    1236                 :            :   (((struct tree_deferred_parse *)DEFERRED_PARSE_CHECK (NODE))->instantiations)
    1237                 :            : 
    1238                 :            : struct GTY (()) tree_deferred_parse {
    1239                 :            :   struct tree_base base;
    1240                 :            :   struct cp_token_cache *tokens;
    1241                 :            :   vec<tree, va_gc> *instantiations;
    1242                 :            : };
    1243                 :            : 
    1244                 :            : 
    1245                 :            : #define DEFERRED_NOEXCEPT_PATTERN(NODE) \
    1246                 :            :   (((struct tree_deferred_noexcept *)DEFERRED_NOEXCEPT_CHECK (NODE))->pattern)
    1247                 :            : #define DEFERRED_NOEXCEPT_ARGS(NODE) \
    1248                 :            :   (((struct tree_deferred_noexcept *)DEFERRED_NOEXCEPT_CHECK (NODE))->args)
    1249                 :            : #define DEFERRED_NOEXCEPT_SPEC_P(NODE)                          \
    1250                 :            :   ((NODE) && (TREE_PURPOSE (NODE))                              \
    1251                 :            :    && (TREE_CODE (TREE_PURPOSE (NODE)) == DEFERRED_NOEXCEPT))
    1252                 :            : #define UNEVALUATED_NOEXCEPT_SPEC_P(NODE)                               \
    1253                 :            :   (DEFERRED_NOEXCEPT_SPEC_P (NODE)                                      \
    1254                 :            :    && DEFERRED_NOEXCEPT_PATTERN (TREE_PURPOSE (NODE)) == NULL_TREE)
    1255                 :            : #define UNPARSED_NOEXCEPT_SPEC_P(NODE) \
    1256                 :            :   ((NODE) && (TREE_PURPOSE (NODE)) \
    1257                 :            :    && (TREE_CODE (TREE_PURPOSE (NODE)) == DEFERRED_PARSE))
    1258                 :            : 
    1259                 :            : struct GTY (()) tree_deferred_noexcept {
    1260                 :            :   struct tree_base base;
    1261                 :            :   tree pattern;
    1262                 :            :   tree args;
    1263                 :            : };
    1264                 :            : 
    1265                 :            : 
    1266                 :            : /* The condition associated with the static assertion.  This must be
    1267                 :            :    an integral constant expression.  */
    1268                 :            : #define STATIC_ASSERT_CONDITION(NODE) \
    1269                 :            :   (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->condition)
    1270                 :            : 
    1271                 :            : /* The message associated with the static assertion.  This must be a
    1272                 :            :    string constant, which will be emitted as an error message when the
    1273                 :            :    static assert condition is false.  */
    1274                 :            : #define STATIC_ASSERT_MESSAGE(NODE) \
    1275                 :            :   (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->message)
    1276                 :            : 
    1277                 :            : /* Source location information for a static assertion.  */
    1278                 :            : #define STATIC_ASSERT_SOURCE_LOCATION(NODE) \
    1279                 :            :   (((struct tree_static_assert *)STATIC_ASSERT_CHECK (NODE))->location)
    1280                 :            : 
    1281                 :            : struct GTY (()) tree_static_assert {
    1282                 :            :   struct tree_common common;
    1283                 :            :   tree condition;
    1284                 :            :   tree message;
    1285                 :            :   location_t location;
    1286                 :            : };
    1287                 :            : 
    1288                 :            : struct GTY (()) tree_argument_pack_select {
    1289                 :            :   struct tree_common common;
    1290                 :            :   tree argument_pack;
    1291                 :            :   int index;
    1292                 :            : };
    1293                 :            : 
    1294                 :            : /* The different kinds of traits that we encounter.  */
    1295                 :            : 
    1296                 :            : enum cp_trait_kind
    1297                 :            : {
    1298                 :            :   CPTK_BASES,
    1299                 :            :   CPTK_DIRECT_BASES,
    1300                 :            :   CPTK_HAS_NOTHROW_ASSIGN,
    1301                 :            :   CPTK_HAS_NOTHROW_CONSTRUCTOR,
    1302                 :            :   CPTK_HAS_NOTHROW_COPY,
    1303                 :            :   CPTK_HAS_TRIVIAL_ASSIGN,
    1304                 :            :   CPTK_HAS_TRIVIAL_CONSTRUCTOR,
    1305                 :            :   CPTK_HAS_TRIVIAL_COPY,
    1306                 :            :   CPTK_HAS_TRIVIAL_DESTRUCTOR,
    1307                 :            :   CPTK_HAS_UNIQUE_OBJ_REPRESENTATIONS,
    1308                 :            :   CPTK_HAS_VIRTUAL_DESTRUCTOR,
    1309                 :            :   CPTK_IS_ABSTRACT,
    1310                 :            :   CPTK_IS_AGGREGATE,
    1311                 :            :   CPTK_IS_BASE_OF,
    1312                 :            :   CPTK_IS_CLASS,
    1313                 :            :   CPTK_IS_EMPTY,
    1314                 :            :   CPTK_IS_ENUM,
    1315                 :            :   CPTK_IS_FINAL,
    1316                 :            :   CPTK_IS_LITERAL_TYPE,
    1317                 :            :   CPTK_IS_POD,
    1318                 :            :   CPTK_IS_POLYMORPHIC,
    1319                 :            :   CPTK_IS_SAME_AS,
    1320                 :            :   CPTK_IS_STD_LAYOUT,
    1321                 :            :   CPTK_IS_TRIVIAL,
    1322                 :            :   CPTK_IS_TRIVIALLY_ASSIGNABLE,
    1323                 :            :   CPTK_IS_TRIVIALLY_CONSTRUCTIBLE,
    1324                 :            :   CPTK_IS_TRIVIALLY_COPYABLE,
    1325                 :            :   CPTK_IS_UNION,
    1326                 :            :   CPTK_UNDERLYING_TYPE,
    1327                 :            :   CPTK_IS_ASSIGNABLE,
    1328                 :            :   CPTK_IS_CONSTRUCTIBLE
    1329                 :            : };
    1330                 :            : 
    1331                 :            : /* The types that we are processing.  */
    1332                 :            : #define TRAIT_EXPR_TYPE1(NODE) \
    1333                 :            :   (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->type1)
    1334                 :            : 
    1335                 :            : #define TRAIT_EXPR_TYPE2(NODE) \
    1336                 :            :   (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->type2)
    1337                 :            : 
    1338                 :            : /* The specific trait that we are processing.  */
    1339                 :            : #define TRAIT_EXPR_KIND(NODE) \
    1340                 :            :   (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->kind)
    1341                 :            : 
    1342                 :            : #define TRAIT_EXPR_LOCATION(NODE) \
    1343                 :            :   (((struct tree_trait_expr *)TRAIT_EXPR_CHECK (NODE))->locus)
    1344                 :            : 
    1345                 :            : struct GTY (()) tree_trait_expr {
    1346                 :            :   struct tree_common common;
    1347                 :            :   tree type1;
    1348                 :            :   tree type2;
    1349                 :            :   location_t locus;
    1350                 :            :   enum cp_trait_kind kind;
    1351                 :            : };
    1352                 :            : 
    1353                 :            : /* Identifiers used for lambda types are almost anonymous.  Use this
    1354                 :            :    spare flag to distinguish them (they also have the anonymous flag).  */
    1355                 :            : #define IDENTIFIER_LAMBDA_P(NODE) \
    1356                 :            :   (IDENTIFIER_NODE_CHECK(NODE)->base.protected_flag)
    1357                 :            : 
    1358                 :            : /* Based off of TYPE_UNNAMED_P.  */
    1359                 :            : #define LAMBDA_TYPE_P(NODE)                     \
    1360                 :            :   (TREE_CODE (NODE) == RECORD_TYPE              \
    1361                 :            :    && TYPE_LINKAGE_IDENTIFIER (NODE)                            \
    1362                 :            :    && IDENTIFIER_LAMBDA_P (TYPE_LINKAGE_IDENTIFIER (NODE)))
    1363                 :            : 
    1364                 :            : /* Test if FUNCTION_DECL is a lambda function.  */
    1365                 :            : #define LAMBDA_FUNCTION_P(FNDECL)                               \
    1366                 :            :   (DECL_DECLARES_FUNCTION_P (FNDECL)                            \
    1367                 :            :    && DECL_OVERLOADED_OPERATOR_P (FNDECL)                       \
    1368                 :            :    && DECL_OVERLOADED_OPERATOR_IS (FNDECL, CALL_EXPR)           \
    1369                 :            :    && LAMBDA_TYPE_P (CP_DECL_CONTEXT (FNDECL)))
    1370                 :            : 
    1371                 :            : enum cp_lambda_default_capture_mode_type {
    1372                 :            :   CPLD_NONE,
    1373                 :            :   CPLD_COPY,
    1374                 :            :   CPLD_REFERENCE
    1375                 :            : };
    1376                 :            : 
    1377                 :            : /* The method of default capture, if any.  */
    1378                 :            : #define LAMBDA_EXPR_DEFAULT_CAPTURE_MODE(NODE) \
    1379                 :            :   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->default_capture_mode)
    1380                 :            : 
    1381                 :            : /* The capture-list, including `this'.  Each capture is stored as a FIELD_DECL
    1382                 :            :  * so that the name, type, and field are all together, whether or not it has
    1383                 :            :  * been added to the lambda's class type.
    1384                 :            :    TREE_LIST:
    1385                 :            :      TREE_PURPOSE: The FIELD_DECL for this capture.
    1386                 :            :      TREE_VALUE: The initializer. This is part of a GNU extension.  */
    1387                 :            : #define LAMBDA_EXPR_CAPTURE_LIST(NODE) \
    1388                 :            :   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->capture_list)
    1389                 :            : 
    1390                 :            : /* During parsing of the lambda-introducer, the node in the capture-list
    1391                 :            :    that holds the 'this' capture.  During parsing of the body, the
    1392                 :            :    capture proxy for that node.  */
    1393                 :            : #define LAMBDA_EXPR_THIS_CAPTURE(NODE) \
    1394                 :            :   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->this_capture)
    1395                 :            : 
    1396                 :            : /* Predicate tracking whether `this' is in the effective capture set.  */
    1397                 :            : #define LAMBDA_EXPR_CAPTURES_THIS_P(NODE) \
    1398                 :            :   LAMBDA_EXPR_THIS_CAPTURE(NODE)
    1399                 :            : 
    1400                 :            : /* Predicate tracking whether the lambda was declared 'mutable'.  */
    1401                 :            : #define LAMBDA_EXPR_MUTABLE_P(NODE) \
    1402                 :            :   TREE_LANG_FLAG_1 (LAMBDA_EXPR_CHECK (NODE))
    1403                 :            : 
    1404                 :            : /* True iff uses of a const variable capture were optimized away.  */
    1405                 :            : #define LAMBDA_EXPR_CAPTURE_OPTIMIZED(NODE) \
    1406                 :            :   TREE_LANG_FLAG_2 (LAMBDA_EXPR_CHECK (NODE))
    1407                 :            : 
    1408                 :            : /* True iff this LAMBDA_EXPR was generated in tsubst_lambda_expr.  */
    1409                 :            : #define LAMBDA_EXPR_INSTANTIATED(NODE) \
    1410                 :            :   TREE_LANG_FLAG_3 (LAMBDA_EXPR_CHECK (NODE))
    1411                 :            : 
    1412                 :            : /* True if this TREE_LIST in LAMBDA_EXPR_CAPTURE_LIST is for an explicit
    1413                 :            :    capture.  */
    1414                 :            : #define LAMBDA_CAPTURE_EXPLICIT_P(NODE) \
    1415                 :            :   TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
    1416                 :            : 
    1417                 :            : /* The source location of the lambda.  */
    1418                 :            : #define LAMBDA_EXPR_LOCATION(NODE) \
    1419                 :            :   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->locus)
    1420                 :            : 
    1421                 :            : /* The mangling scope for the lambda: FUNCTION_DECL, PARM_DECL, VAR_DECL,
    1422                 :            :    FIELD_DECL or NULL_TREE.  If this is NULL_TREE, we have no linkage.  */
    1423                 :            : #define LAMBDA_EXPR_EXTRA_SCOPE(NODE) \
    1424                 :            :   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->extra_scope)
    1425                 :            : 
    1426                 :            : /* If EXTRA_SCOPE, this is the number of the lambda within that scope.  */
    1427                 :            : #define LAMBDA_EXPR_DISCRIMINATOR(NODE) \
    1428                 :            :   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->discriminator)
    1429                 :            : 
    1430                 :            : /* During parsing of the lambda, a vector of capture proxies which need
    1431                 :            :    to be pushed once we're done processing a nested lambda.  */
    1432                 :            : #define LAMBDA_EXPR_PENDING_PROXIES(NODE) \
    1433                 :            :   (((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->pending_proxies)
    1434                 :            : 
    1435                 :            : /* The closure type of the lambda, which is also the type of the
    1436                 :            :    LAMBDA_EXPR.  */
    1437                 :            : #define LAMBDA_EXPR_CLOSURE(NODE) \
    1438                 :            :   (TREE_TYPE (LAMBDA_EXPR_CHECK (NODE)))
    1439                 :            : 
    1440                 :            : struct GTY (()) tree_lambda_expr
    1441                 :            : {
    1442                 :            :   struct tree_typed typed;
    1443                 :            :   tree capture_list;
    1444                 :            :   tree this_capture;
    1445                 :            :   tree extra_scope;
    1446                 :            :   vec<tree, va_gc> *pending_proxies;
    1447                 :            :   location_t locus;
    1448                 :            :   enum cp_lambda_default_capture_mode_type default_capture_mode;
    1449                 :            :   int discriminator;
    1450                 :            : };
    1451                 :            : 
    1452                 :            : /* A (typedef,context,usage location) triplet.
    1453                 :            :    It represents a typedef used through a
    1454                 :            :    context at a given source location.
    1455                 :            :    e.g.
    1456                 :            :    struct foo {
    1457                 :            :      typedef int myint;
    1458                 :            :    };
    1459                 :            : 
    1460                 :            :    struct bar {
    1461                 :            :     foo::myint v; // #1<-- this location.
    1462                 :            :    };
    1463                 :            : 
    1464                 :            :    In bar, the triplet will be (myint, foo, #1).
    1465                 :            :    */
    1466                 :            : struct GTY(()) qualified_typedef_usage_s {
    1467                 :            :   tree typedef_decl;
    1468                 :            :   tree context;
    1469                 :            :   location_t locus;
    1470                 :            : };
    1471                 :            : typedef struct qualified_typedef_usage_s qualified_typedef_usage_t;
    1472                 :            : 
    1473                 :            : /* Non-zero if this template specialization has access violations that
    1474                 :            :    should be rechecked when the function is instantiated outside argument
    1475                 :            :    deduction.  */
    1476                 :            : #define TINFO_HAS_ACCESS_ERRORS(NODE) \
    1477                 :            :   (TREE_LANG_FLAG_0 (TEMPLATE_INFO_CHECK (NODE)))
    1478                 :            : #define FNDECL_HAS_ACCESS_ERRORS(NODE) \
    1479                 :            :   (TINFO_HAS_ACCESS_ERRORS (DECL_TEMPLATE_INFO (NODE)))
    1480                 :            : 
    1481                 :            : /* Non-zero if this variable template specialization was specified using a
    1482                 :            :    template-id, so it's a partial or full specialization and not a definition
    1483                 :            :    of the member template of a particular class specialization.  */
    1484                 :            : #define TINFO_USED_TEMPLATE_ID(NODE) \
    1485                 :            :   (TREE_LANG_FLAG_1 (TEMPLATE_INFO_CHECK (NODE)))
    1486                 :            : 
    1487                 :            : /* Non-zero if this variable template specialization was declared with the
    1488                 :            :    `constinit' specifier.  */
    1489                 :            : #define TINFO_VAR_DECLARED_CONSTINIT(NODE) \
    1490                 :            :   (TREE_LANG_FLAG_2 (TEMPLATE_INFO_CHECK (NODE)))
    1491                 :            : 
    1492                 :            : struct GTY(()) tree_template_info {
    1493                 :            :   struct tree_base base;
    1494                 :            :   tree tmpl;
    1495                 :            :   tree args;
    1496                 :            :   vec<qualified_typedef_usage_t, va_gc> *typedefs_needing_access_checking;
    1497                 :            : };
    1498                 :            : 
    1499                 :            : // Constraint information for a C++ declaration. Constraint information is
    1500                 :            : // comprised of:
    1501                 :            : //
    1502                 :            : // - a constraint expression introduced by the template header
    1503                 :            : // - a constraint expression introduced by a function declarator
    1504                 :            : // - the associated constraints, which are the conjunction of those,
    1505                 :            : //   and used for declaration matching
    1506                 :            : //
    1507                 :            : // The template and declarator requirements are kept to support pretty
    1508                 :            : // printing constrained declarations.
    1509                 :            : struct GTY(()) tree_constraint_info {
    1510                 :            :   struct tree_base base;
    1511                 :            :   tree template_reqs;
    1512                 :            :   tree declarator_reqs;
    1513                 :            :   tree associated_constr;
    1514                 :            : };
    1515                 :            : 
    1516                 :            : // Require that pointer P is non-null before returning.
    1517                 :            : template<typename T>
    1518                 :            : inline T*
    1519                 :      82263 : check_nonnull (T* p)
    1520                 :            : {
    1521                 :            :   gcc_assert (p);
    1522                 :            :   return p;
    1523                 :            : }
    1524                 :            : 
    1525                 :            : /* Returns true iff T is non-null and represents constraint info.  */
    1526                 :            : inline tree_constraint_info *
    1527                 :     212636 : check_constraint_info (tree t)
    1528                 :            : {
    1529                 :     212079 :   if (t && TREE_CODE (t) == CONSTRAINT_INFO)
    1530                 :     212132 :     return (tree_constraint_info *)t;
    1531                 :            :   return NULL;
    1532                 :            : }
    1533                 :            : 
    1534                 :            : /* Access the expression describing the template constraints. This may be
    1535                 :            :    null if no constraints were introduced in the template parameter list,
    1536                 :            :    a requirements clause after the template parameter list, or constraints
    1537                 :            :    through a constrained-type-specifier.  */
    1538                 :            : #define CI_TEMPLATE_REQS(NODE) \
    1539                 :            :   check_constraint_info (check_nonnull (NODE))->template_reqs
    1540                 :            : 
    1541                 :            : /* Access the expression describing the trailing constraints. This is non-null
    1542                 :            :    for any implicit instantiation of a constrained declaration. For a
    1543                 :            :    templated declaration it is non-null only when a trailing requires-clause
    1544                 :            :    was specified.  */
    1545                 :            : #define CI_DECLARATOR_REQS(NODE) \
    1546                 :            :   check_constraint_info (check_nonnull (NODE))->declarator_reqs
    1547                 :            : 
    1548                 :            : /* The computed associated constraint expression for a declaration.  */
    1549                 :            : #define CI_ASSOCIATED_CONSTRAINTS(NODE) \
    1550                 :            :   check_constraint_info (check_nonnull (NODE))->associated_constr
    1551                 :            : 
    1552                 :            : /* Access the constraint-expression introduced by the requires-clause
    1553                 :            :    associate the template parameter list NODE.  */
    1554                 :            : #define TEMPLATE_PARMS_CONSTRAINTS(NODE) \
    1555                 :            :   TREE_TYPE (TREE_LIST_CHECK (NODE))
    1556                 :            : 
    1557                 :            : /* Access the logical constraints on the template parameter declaration
    1558                 :            :    indicated by NODE.  */
    1559                 :            : #define TEMPLATE_PARM_CONSTRAINTS(NODE) \
    1560                 :            :   TREE_TYPE (TREE_LIST_CHECK (NODE))
    1561                 :            : 
    1562                 :            : /* Non-zero if the noexcept is present in a compound requirement.  */
    1563                 :            : #define COMPOUND_REQ_NOEXCEPT_P(NODE) \
    1564                 :            :   TREE_LANG_FLAG_0 (TREE_CHECK (NODE, COMPOUND_REQ))
    1565                 :            : 
    1566                 :            : /* The constraints on an 'auto' placeholder type, used in an argument deduction
    1567                 :            :    constraint.  */
    1568                 :            : #define PLACEHOLDER_TYPE_CONSTRAINTS(NODE) \
    1569                 :            :   DECL_SIZE_UNIT (TYPE_NAME (NODE))
    1570                 :            : 
    1571                 :            : /* True if NODE is a constraint.  */
    1572                 :            : #define CONSTR_P(NODE)                  \
    1573                 :            :   (TREE_CODE (NODE) == ATOMIC_CONSTR    \
    1574                 :            :    || TREE_CODE (NODE) == CONJ_CONSTR   \
    1575                 :            :    || TREE_CODE (NODE) == DISJ_CONSTR)
    1576                 :            : 
    1577                 :            : /* Valid for any normalized constraint.  */
    1578                 :            : #define CONSTR_CHECK(NODE) \
    1579                 :            :   TREE_CHECK3 (NODE, ATOMIC_CONSTR, CONJ_CONSTR, DISJ_CONSTR)
    1580                 :            : 
    1581                 :            : /* The CONSTR_INFO stores normalization data for a constraint. It refers to
    1582                 :            :    the original expression and the expression or declaration
    1583                 :            :    from which the constraint was normalized.
    1584                 :            : 
    1585                 :            :    This is TREE_LIST whose TREE_PURPOSE is the original expression and whose
    1586                 :            :    TREE_VALUE is a list of contexts.  */
    1587                 :            : #define CONSTR_INFO(NODE) \
    1588                 :            :   TREE_TYPE (CONSTR_CHECK (NODE))
    1589                 :            : 
    1590                 :            : /* The expression evaluated by the constraint.  */
    1591                 :            : #define CONSTR_EXPR(NODE) \
    1592                 :            :   TREE_PURPOSE (CONSTR_INFO (NODE))
    1593                 :            : 
    1594                 :            : /* The expression or declaration from which this constraint was normalized.
    1595                 :            :    This is a TREE_LIST whose TREE_VALUE is either a template-id expression
    1596                 :            :    denoting a concept check or the declaration introducing the constraint.
    1597                 :            :    These are chained to other context objects.  */
    1598                 :            : #define CONSTR_CONTEXT(NODE) \
    1599                 :            :   TREE_VALUE (CONSTR_INFO (NODE))
    1600                 :            : 
    1601                 :            : /* The parameter mapping for an atomic constraint. */
    1602                 :            : #define ATOMIC_CONSTR_MAP(NODE) \
    1603                 :            :   TREE_OPERAND (TREE_CHECK (NODE, ATOMIC_CONSTR), 0)
    1604                 :            : 
    1605                 :            : /* The expression of an atomic constraint. */
    1606                 :            : #define ATOMIC_CONSTR_EXPR(NODE) \
    1607                 :            :   CONSTR_EXPR (ATOMIC_CONSTR_CHECK (NODE))
    1608                 :            : 
    1609                 :            : /* The concept of a concept check. */
    1610                 :            : #define CHECK_CONSTR_CONCEPT(NODE) \
    1611                 :            :   TREE_OPERAND (TREE_CHECK (NODE, CHECK_CONSTR), 0)
    1612                 :            : 
    1613                 :            : /* The template arguments of a concept check. */
    1614                 :            : #define CHECK_CONSTR_ARGS(NODE) \
    1615                 :            :   TREE_OPERAND (TREE_CHECK (NODE, CHECK_CONSTR), 1)
    1616                 :            : 
    1617                 :            : /* Whether a PARM_DECL represents a local parameter in a
    1618                 :            :    requires-expression.  */
    1619                 :            : #define CONSTRAINT_VAR_P(NODE) \
    1620                 :            :   DECL_LANG_FLAG_2 (TREE_CHECK (NODE, PARM_DECL))
    1621                 :            : 
    1622                 :            : /* The concept constraining this constrained template-parameter.  */
    1623                 :            : #define CONSTRAINED_PARM_CONCEPT(NODE) \
    1624                 :            :   DECL_SIZE_UNIT (TYPE_DECL_CHECK (NODE))
    1625                 :            : /* Any extra template arguments specified for a constrained
    1626                 :            :    template-parameter.  */
    1627                 :            : #define CONSTRAINED_PARM_EXTRA_ARGS(NODE) \
    1628                 :            :   DECL_SIZE (TYPE_DECL_CHECK (NODE))
    1629                 :            : /* The first template parameter of CONSTRAINED_PARM_CONCEPT to be used as a
    1630                 :            :    prototype for the constrained parameter in finish_shorthand_constraint,
    1631                 :            :    attached for convenience.  */
    1632                 :            : #define CONSTRAINED_PARM_PROTOTYPE(NODE) \
    1633                 :            :   DECL_INITIAL (TYPE_DECL_CHECK (NODE))
    1634                 :            : 
    1635                 :            : enum cp_tree_node_structure_enum {
    1636                 :            :   TS_CP_GENERIC,
    1637                 :            :   TS_CP_IDENTIFIER,
    1638                 :            :   TS_CP_TPI,
    1639                 :            :   TS_CP_PTRMEM,
    1640                 :            :   TS_CP_OVERLOAD,
    1641                 :            :   TS_CP_BASELINK,
    1642                 :            :   TS_CP_TEMPLATE_DECL,
    1643                 :            :   TS_CP_DEFERRED_PARSE,
    1644                 :            :   TS_CP_DEFERRED_NOEXCEPT,
    1645                 :            :   TS_CP_STATIC_ASSERT,
    1646                 :            :   TS_CP_ARGUMENT_PACK_SELECT,
    1647                 :            :   TS_CP_TRAIT_EXPR,
    1648                 :            :   TS_CP_LAMBDA_EXPR,
    1649                 :            :   TS_CP_TEMPLATE_INFO,
    1650                 :            :   TS_CP_CONSTRAINT_INFO,
    1651                 :            :   TS_CP_USERDEF_LITERAL
    1652                 :            : };
    1653                 :            : 
    1654                 :            : /* The resulting tree type.  */
    1655                 :            : union GTY((desc ("cp_tree_node_structure (&%h)"),
    1656                 :            :        chain_next ("(union lang_tree_node *) c_tree_chain_next (&%h.generic)"))) lang_tree_node {
    1657                 :            :   union tree_node GTY ((tag ("TS_CP_GENERIC"),
    1658                 :            :                         desc ("tree_node_structure (&%h)"))) generic;
    1659                 :            :   struct template_parm_index GTY ((tag ("TS_CP_TPI"))) tpi;
    1660                 :            :   struct ptrmem_cst GTY ((tag ("TS_CP_PTRMEM"))) ptrmem;
    1661                 :            :   struct tree_overload GTY ((tag ("TS_CP_OVERLOAD"))) overload;
    1662                 :            :   struct tree_baselink GTY ((tag ("TS_CP_BASELINK"))) baselink;
    1663                 :            :   struct tree_template_decl GTY ((tag ("TS_CP_TEMPLATE_DECL"))) template_decl;
    1664                 :            :   struct tree_deferred_parse GTY ((tag ("TS_CP_DEFERRED_PARSE"))) deferred_parse;
    1665                 :            :   struct tree_deferred_noexcept GTY ((tag ("TS_CP_DEFERRED_NOEXCEPT"))) deferred_noexcept;
    1666                 :            :   struct lang_identifier GTY ((tag ("TS_CP_IDENTIFIER"))) identifier;
    1667                 :            :   struct tree_static_assert GTY ((tag ("TS_CP_STATIC_ASSERT")))
    1668                 :            :     static_assertion;
    1669                 :            :   struct tree_argument_pack_select GTY ((tag ("TS_CP_ARGUMENT_PACK_SELECT")))
    1670                 :            :     argument_pack_select;
    1671                 :            :   struct tree_trait_expr GTY ((tag ("TS_CP_TRAIT_EXPR")))
    1672                 :            :     trait_expression;
    1673                 :            :   struct tree_lambda_expr GTY ((tag ("TS_CP_LAMBDA_EXPR")))
    1674                 :            :     lambda_expression;
    1675                 :            :   struct tree_template_info GTY ((tag ("TS_CP_TEMPLATE_INFO")))
    1676                 :            :     template_info;
    1677                 :            :   struct tree_constraint_info GTY ((tag ("TS_CP_CONSTRAINT_INFO")))
    1678                 :            :     constraint_info;
    1679                 :            :   struct tree_userdef_literal GTY ((tag ("TS_CP_USERDEF_LITERAL")))
    1680                 :            :     userdef_literal;
    1681                 :            : };
    1682                 :            : 
    1683                 :            : 
    1684                 :            : /* Global state.  */
    1685                 :            : 
    1686                 :            : struct GTY(()) saved_scope {
    1687                 :            :   vec<cxx_saved_binding, va_gc> *old_bindings;
    1688                 :            :   tree old_namespace;
    1689                 :            :   vec<tree, va_gc> *decl_ns_list;
    1690                 :            :   tree class_name;
    1691                 :            :   tree class_type;
    1692                 :            :   tree access_specifier;
    1693                 :            :   tree function_decl;
    1694                 :            :   vec<tree, va_gc> *lang_base;
    1695                 :            :   tree lang_name;
    1696                 :            :   tree template_parms;
    1697                 :            :   cp_binding_level *x_previous_class_level;
    1698                 :            :   tree x_saved_tree;
    1699                 :            : 
    1700                 :            :   /* Only used for uses of this in trailing return type.  */
    1701                 :            :   tree x_current_class_ptr;
    1702                 :            :   tree x_current_class_ref;
    1703                 :            : 
    1704                 :            :   int x_processing_template_decl;
    1705                 :            :   int x_processing_specialization;
    1706                 :            :   int x_processing_constraint;
    1707                 :            :   int suppress_location_wrappers;
    1708                 :            :   BOOL_BITFIELD x_processing_explicit_instantiation : 1;
    1709                 :            :   BOOL_BITFIELD need_pop_function_context : 1;
    1710                 :            : 
    1711                 :            : /* Nonzero if we are parsing the discarded statement of a constexpr
    1712                 :            :    if-statement.  */
    1713                 :            :   BOOL_BITFIELD discarded_stmt : 1;
    1714                 :            : 
    1715                 :            :   int unevaluated_operand;
    1716                 :            :   int inhibit_evaluation_warnings;
    1717                 :            :   int noexcept_operand;
    1718                 :            :   /* If non-zero, implicit "omp declare target" attribute is added into the
    1719                 :            :      attribute lists.  */
    1720                 :            :   int omp_declare_target_attribute;
    1721                 :            :   int ref_temp_count;
    1722                 :            : 
    1723                 :            :   struct stmt_tree_s x_stmt_tree;
    1724                 :            : 
    1725                 :            :   cp_binding_level *class_bindings;
    1726                 :            :   cp_binding_level *bindings;
    1727                 :            : 
    1728                 :            :   hash_map<tree, tree> *GTY((skip)) x_local_specializations;
    1729                 :            : 
    1730                 :            :   struct saved_scope *prev;
    1731                 :            : };
    1732                 :            : 
    1733                 :            : extern GTY(()) struct saved_scope *scope_chain;
    1734                 :            : 
    1735                 :            : /* The current open namespace.  */
    1736                 :            : 
    1737                 :            : #define current_namespace scope_chain->old_namespace
    1738                 :            : 
    1739                 :            : /* The stack for namespaces of current declarations.  */
    1740                 :            : 
    1741                 :            : #define decl_namespace_list scope_chain->decl_ns_list
    1742                 :            : 
    1743                 :            : /* IDENTIFIER_NODE: name of current class */
    1744                 :            : 
    1745                 :            : #define current_class_name scope_chain->class_name
    1746                 :            : 
    1747                 :            : /* _TYPE: the type of the current class */
    1748                 :            : 
    1749                 :            : #define current_class_type scope_chain->class_type
    1750                 :            : 
    1751                 :            : /* When parsing a class definition, the access specifier most recently
    1752                 :            :    given by the user, or, if no access specifier was given, the
    1753                 :            :    default value appropriate for the kind of class (i.e., struct,
    1754                 :            :    class, or union).  */
    1755                 :            : 
    1756                 :            : #define current_access_specifier scope_chain->access_specifier
    1757                 :            : 
    1758                 :            : /* Pointer to the top of the language name stack.  */
    1759                 :            : 
    1760                 :            : #define current_lang_base scope_chain->lang_base
    1761                 :            : #define current_lang_name scope_chain->lang_name
    1762                 :            : 
    1763                 :            : /* When parsing a template declaration, a TREE_LIST represents the
    1764                 :            :    active template parameters.  Each node in the list represents one
    1765                 :            :    level of template parameters.  The innermost level is first in the
    1766                 :            :    list.  The depth of each level is stored as an INTEGER_CST in the
    1767                 :            :    TREE_PURPOSE of each node.  The parameters for that level are
    1768                 :            :    stored in the TREE_VALUE.  */
    1769                 :            : 
    1770                 :            : #define current_template_parms scope_chain->template_parms
    1771                 :            : 
    1772                 :            : #define processing_template_decl scope_chain->x_processing_template_decl
    1773                 :            : #define processing_specialization scope_chain->x_processing_specialization
    1774                 :            : #define processing_explicit_instantiation scope_chain->x_processing_explicit_instantiation
    1775                 :            : 
    1776                 :            : #define in_discarded_stmt scope_chain->discarded_stmt
    1777                 :            : 
    1778                 :            : #define current_ref_temp_count scope_chain->ref_temp_count
    1779                 :            : 
    1780                 :            : /* RAII sentinel to handle clearing processing_template_decl and restoring
    1781                 :            :    it when done.  */
    1782                 :            : 
    1783                 :            : class processing_template_decl_sentinel
    1784                 :            : {
    1785                 :            : public:
    1786                 :            :   int saved;
    1787                 :   67718366 :   processing_template_decl_sentinel (bool reset = true)
    1788                 :   67718366 :     : saved (processing_template_decl)
    1789                 :            :   {
    1790                 :   48388966 :     if (reset)
    1791                 :   32232566 :       processing_template_decl = 0;
    1792                 :            :   }
    1793                 :   67715666 :   ~processing_template_decl_sentinel()
    1794                 :   67715666 :   {
    1795                 :   13985066 :     processing_template_decl = saved;
    1796                 :   40521700 :   }
    1797                 :            : };
    1798                 :            : 
    1799                 :            : /* RAII sentinel to disable certain warnings during template substitution
    1800                 :            :    and elsewhere.  */
    1801                 :            : 
    1802                 :            : class warning_sentinel
    1803                 :            : {
    1804                 :            : public:
    1805                 :            :   int &flag;
    1806                 :            :   int val;
    1807                 :   80317958 :   warning_sentinel(int& flag, bool suppress=true)
    1808                 :   60286558 :     : flag(flag), val(flag) { if (suppress) flag = 0; }
    1809                 :   60285558 :   ~warning_sentinel() { flag = val; }
    1810                 :            : };
    1811                 :            : 
    1812                 :            : /* RAII sentinel to temporarily override input_location.  This will not set
    1813                 :            :    input_location to UNKNOWN_LOCATION or BUILTINS_LOCATION.  */
    1814                 :            : 
    1815                 :            : class iloc_sentinel
    1816                 :            : {
    1817                 :            :   location_t saved_loc;
    1818                 :            : public:
    1819                 :   67614284 :   iloc_sentinel (location_t loc): saved_loc (input_location)
    1820                 :            :   {
    1821                 :   67614284 :     if (loc >= RESERVED_LOCATION_COUNT)
    1822                 :   64905084 :       input_location = loc;
    1823                 :            :   }
    1824                 :   67611584 :   ~iloc_sentinel ()
    1825                 :   67611584 :   {
    1826                 :   65363535 :     input_location = saved_loc;
    1827                 :          2 :   }
    1828                 :            : };
    1829                 :            : 
    1830                 :            : /* RAII sentinel that saves the value of a variable, optionally
    1831                 :            :    overrides it right away, and restores its value when the sentinel
    1832                 :            :    id destructed.  */
    1833                 :            : 
    1834                 :            : template <typename T>
    1835                 :            : class temp_override
    1836                 :            : {
    1837                 :            :   T& overridden_variable;
    1838                 :            :   T saved_value;
    1839                 :            : public:
    1840                 :   15675336 :   temp_override(T& var) : overridden_variable (var), saved_value (var) {}
    1841                 :  108417009 :   temp_override(T& var, T overrider)
    1842                 :  108417009 :     : overridden_variable (var), saved_value (var)
    1843                 :            :   {
    1844                 :     344090 :     overridden_variable = overrider;
    1845                 :  108073000 :   }
    1846                 :  124092045 :   ~temp_override() { overridden_variable = saved_value; }
    1847                 :            : };
    1848                 :            : 
    1849                 :            : /* The cached class binding level, from the most recently exited
    1850                 :            :    class, or NULL if none.  */
    1851                 :            : 
    1852                 :            : #define previous_class_level scope_chain->x_previous_class_level
    1853                 :            : 
    1854                 :            : /* A map from local variable declarations in the body of the template
    1855                 :            :    presently being instantiated to the corresponding instantiated
    1856                 :            :    local variables.  */
    1857                 :            : 
    1858                 :            : #define local_specializations scope_chain->x_local_specializations
    1859                 :            : 
    1860                 :            : /* Nonzero if we are parsing the operand of a noexcept operator.  */
    1861                 :            : 
    1862                 :            : #define cp_noexcept_operand scope_chain->noexcept_operand
    1863                 :            : 
    1864                 :            : /* A list of private types mentioned, for deferred access checking.  */
    1865                 :            : 
    1866                 :            : struct GTY((for_user)) cxx_int_tree_map {
    1867                 :            :   unsigned int uid;
    1868                 :            :   tree to;
    1869                 :            : };
    1870                 :            : 
    1871                 :            : struct cxx_int_tree_map_hasher : ggc_ptr_hash<cxx_int_tree_map>
    1872                 :            : {
    1873                 :            :   static hashval_t hash (cxx_int_tree_map *);
    1874                 :            :   static bool equal (cxx_int_tree_map *, cxx_int_tree_map *);
    1875                 :            : };
    1876                 :            : 
    1877                 :            : struct named_label_entry; /* Defined in decl.c.  */
    1878                 :            : 
    1879                 :            : struct named_label_hash : ggc_remove <named_label_entry *>
    1880                 :            : {
    1881                 :            :   typedef named_label_entry *value_type;
    1882                 :            :   typedef tree compare_type; /* An identifier.  */
    1883                 :            : 
    1884                 :            :   inline static hashval_t hash (value_type);
    1885                 :            :   inline static bool equal (const value_type, compare_type);
    1886                 :            : 
    1887                 :            :   static const bool empty_zero_p = true;
    1888                 :            :   inline static void mark_empty (value_type &p) {p = NULL;}
    1889                 :     618172 :   inline static bool is_empty (value_type p) {return !p;}
    1890                 :            : 
    1891                 :            :   /* Nothing is deletable.  Everything is insertable.  */
    1892                 :      43906 :   inline static bool is_deleted (value_type) { return false; }
    1893                 :            :   inline static void mark_deleted (value_type) { gcc_unreachable (); }
    1894                 :            : };
    1895                 :            : 
    1896                 :            : /* Global state pertinent to the current function.  */
    1897                 :            : 
    1898                 :            : struct GTY(()) language_function {
    1899                 :            :   struct c_language_function base;
    1900                 :            : 
    1901                 :            :   tree x_cdtor_label;
    1902                 :            :   tree x_current_class_ptr;
    1903                 :            :   tree x_current_class_ref;
    1904                 :            :   tree x_eh_spec_block;
    1905                 :            :   tree x_in_charge_parm;
    1906                 :            :   tree x_vtt_parm;
    1907                 :            :   tree x_return_value;
    1908                 :            : 
    1909                 :            :   BOOL_BITFIELD returns_value : 1;
    1910                 :            :   BOOL_BITFIELD returns_null : 1;
    1911                 :            :   BOOL_BITFIELD returns_abnormally : 1;
    1912                 :            :   BOOL_BITFIELD infinite_loop: 1;
    1913                 :            :   BOOL_BITFIELD x_in_function_try_handler : 1;
    1914                 :            :   BOOL_BITFIELD x_in_base_initializer : 1;
    1915                 :            : 
    1916                 :            :   /* True if this function can throw an exception.  */
    1917                 :            :   BOOL_BITFIELD can_throw : 1;
    1918                 :            : 
    1919                 :            :   BOOL_BITFIELD invalid_constexpr : 1;
    1920                 :            :   BOOL_BITFIELD throwing_cleanup : 1;
    1921                 :            : 
    1922                 :            :   hash_table<named_label_hash> *x_named_labels;
    1923                 :            : 
    1924                 :            :   cp_binding_level *bindings;
    1925                 :            : 
    1926                 :            :   /* Tracking possibly infinite loops.  This is a vec<tree> only because
    1927                 :            :      vec<bool> doesn't work with gtype.  */
    1928                 :            :   vec<tree, va_gc> *infinite_loops;
    1929                 :            :   hash_table<cxx_int_tree_map_hasher> *extern_decl_map;
    1930                 :            : };
    1931                 :            : 
    1932                 :            : /* The current C++-specific per-function global variables.  */
    1933                 :            : 
    1934                 :            : #define cp_function_chain (cfun->language)
    1935                 :            : 
    1936                 :            : /* In a constructor destructor, the point at which all derived class
    1937                 :            :    destroying/construction has been done.  I.e., just before a
    1938                 :            :    constructor returns, or before any base class destroying will be done
    1939                 :            :    in a destructor.  */
    1940                 :            : 
    1941                 :            : #define cdtor_label cp_function_chain->x_cdtor_label
    1942                 :            : 
    1943                 :            : /* When we're processing a member function, current_class_ptr is the
    1944                 :            :    PARM_DECL for the `this' pointer.  The current_class_ref is an
    1945                 :            :    expression for `*this'.  */
    1946                 :            : 
    1947                 :            : #define current_class_ptr                       \
    1948                 :            :   (*(cfun && cp_function_chain                  \
    1949                 :            :      ? &cp_function_chain->x_current_class_ptr   \
    1950                 :            :      : &scope_chain->x_current_class_ptr))
    1951                 :            : #define current_class_ref                       \
    1952                 :            :   (*(cfun && cp_function_chain                  \
    1953                 :            :      ? &cp_function_chain->x_current_class_ref   \
    1954                 :            :      : &scope_chain->x_current_class_ref))
    1955                 :            : 
    1956                 :            : /* The EH_SPEC_BLOCK for the exception-specifiers for the current
    1957                 :            :    function, if any.  */
    1958                 :            : 
    1959                 :            : #define current_eh_spec_block cp_function_chain->x_eh_spec_block
    1960                 :            : 
    1961                 :            : /* The `__in_chrg' parameter for the current function.  Only used for
    1962                 :            :    constructors and destructors.  */
    1963                 :            : 
    1964                 :            : #define current_in_charge_parm cp_function_chain->x_in_charge_parm
    1965                 :            : 
    1966                 :            : /* The `__vtt_parm' parameter for the current function.  Only used for
    1967                 :            :    constructors and destructors.  */
    1968                 :            : 
    1969                 :            : #define current_vtt_parm cp_function_chain->x_vtt_parm
    1970                 :            : 
    1971                 :            : /* A boolean flag to control whether we need to clean up the return value if a
    1972                 :            :    local destructor throws.  Only used in functions that return by value a
    1973                 :            :    class with a destructor.  Which 'tors don't, so we can use the same
    1974                 :            :    field as current_vtt_parm.  */
    1975                 :            : 
    1976                 :            : #define current_retval_sentinel current_vtt_parm
    1977                 :            : 
    1978                 :            : /* Set to 0 at beginning of a function definition, set to 1 if
    1979                 :            :    a return statement that specifies a return value is seen.  */
    1980                 :            : 
    1981                 :            : #define current_function_returns_value cp_function_chain->returns_value
    1982                 :            : 
    1983                 :            : /* Set to 0 at beginning of a function definition, set to 1 if
    1984                 :            :    a return statement with no argument is seen.  */
    1985                 :            : 
    1986                 :            : #define current_function_returns_null cp_function_chain->returns_null
    1987                 :            : 
    1988                 :            : /* Set to 0 at beginning of a function definition, set to 1 if
    1989                 :            :    a call to a noreturn function is seen.  */
    1990                 :            : 
    1991                 :            : #define current_function_returns_abnormally \
    1992                 :            :   cp_function_chain->returns_abnormally
    1993                 :            : 
    1994                 :            : /* Set to 0 at beginning of a function definition, set to 1 if we see an
    1995                 :            :    obvious infinite loop.  This can have false positives and false
    1996                 :            :    negatives, so it should only be used as a heuristic.  */
    1997                 :            : 
    1998                 :            : #define current_function_infinite_loop cp_function_chain->infinite_loop
    1999                 :            : 
    2000                 :            : /* Nonzero if we are processing a base initializer.  Zero elsewhere.  */
    2001                 :            : #define in_base_initializer cp_function_chain->x_in_base_initializer
    2002                 :            : 
    2003                 :            : #define in_function_try_handler cp_function_chain->x_in_function_try_handler
    2004                 :            : 
    2005                 :            : /* Expression always returned from function, or error_mark_node
    2006                 :            :    otherwise, for use by the automatic named return value optimization.  */
    2007                 :            : 
    2008                 :            : #define current_function_return_value \
    2009                 :            :   (cp_function_chain->x_return_value)
    2010                 :            : 
    2011                 :            : /* In parser.c.  */
    2012                 :            : extern tree cp_literal_operator_id (const char *);
    2013                 :            : 
    2014                 :            : #define NON_ERROR(NODE) ((NODE) == error_mark_node ? NULL_TREE : (NODE))
    2015                 :            : 
    2016                 :            : /* TRUE if a tree code represents a statement.  */
    2017                 :            : extern bool statement_code_p[MAX_TREE_CODES];
    2018                 :            : 
    2019                 :            : #define STATEMENT_CODE_P(CODE) statement_code_p[(int) (CODE)]
    2020                 :            : 
    2021                 :            : enum languages { lang_c, lang_cplusplus };
    2022                 :            : 
    2023                 :            : /* Macros to make error reporting functions' lives easier.  */
    2024                 :            : #define TYPE_LINKAGE_IDENTIFIER(NODE) \
    2025                 :            :   (TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (NODE)))
    2026                 :            : #define TYPE_NAME_STRING(NODE) (IDENTIFIER_POINTER (TYPE_IDENTIFIER (NODE)))
    2027                 :            : #define TYPE_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (TYPE_IDENTIFIER (NODE)))
    2028                 :            : 
    2029                 :            : /* Any kind of anonymous type.  */
    2030                 :            : #define TYPE_ANON_P(NODE)                                       \
    2031                 :            :   (TYPE_LINKAGE_IDENTIFIER (NODE)                               \
    2032                 :            :    && IDENTIFIER_ANON_P (TYPE_LINKAGE_IDENTIFIER (NODE)))
    2033                 :            : 
    2034                 :            : /* Nonzero if NODE, a TYPE, has no name for linkage purposes.  */
    2035                 :            : #define TYPE_UNNAMED_P(NODE)                                    \
    2036                 :            :   (TYPE_ANON_P (NODE)                                           \
    2037                 :            :    && !IDENTIFIER_LAMBDA_P (TYPE_LINKAGE_IDENTIFIER (NODE)))
    2038                 :            : 
    2039                 :            : /* The _DECL for this _TYPE.  */
    2040                 :            : #define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE)))
    2041                 :            : 
    2042                 :            : /* Nonzero if T is a type that could resolve to any kind of concrete type
    2043                 :            :    at instantiation time.  */
    2044                 :            : #define WILDCARD_TYPE_P(T)                              \
    2045                 :            :   (TREE_CODE (T) == TEMPLATE_TYPE_PARM                  \
    2046                 :            :    || TREE_CODE (T) == TYPENAME_TYPE                    \
    2047                 :            :    || TREE_CODE (T) == TYPEOF_TYPE                      \
    2048                 :            :    || TREE_CODE (T) == BOUND_TEMPLATE_TEMPLATE_PARM     \
    2049                 :            :    || TREE_CODE (T) == DECLTYPE_TYPE)
    2050                 :            : 
    2051                 :            : /* Nonzero if T is a class (or struct or union) type.  Also nonzero
    2052                 :            :    for template type parameters, typename types, and instantiated
    2053                 :            :    template template parameters.  Keep these checks in ascending code
    2054                 :            :    order.  */
    2055                 :            : #define MAYBE_CLASS_TYPE_P(T) (WILDCARD_TYPE_P (T) || CLASS_TYPE_P (T))
    2056                 :            : 
    2057                 :            : /* Set CLASS_TYPE_P for T to VAL.  T must be a class, struct, or
    2058                 :            :    union type.  */
    2059                 :            : #define SET_CLASS_TYPE_P(T, VAL) \
    2060                 :            :   (TYPE_LANG_FLAG_5 (RECORD_OR_UNION_CHECK (T)) = (VAL))
    2061                 :            : 
    2062                 :            : /* Nonzero if T is a class type.  Zero for template type parameters,
    2063                 :            :    typename types, and so forth.  */
    2064                 :            : #define CLASS_TYPE_P(T) \
    2065                 :            :   (RECORD_OR_UNION_CODE_P (TREE_CODE (T)) && TYPE_LANG_FLAG_5 (T))
    2066                 :            : 
    2067                 :            : /* Nonzero if T is a class type but not an union.  */
    2068                 :            : #define NON_UNION_CLASS_TYPE_P(T) \
    2069                 :            :   (TREE_CODE (T) == RECORD_TYPE && TYPE_LANG_FLAG_5 (T))
    2070                 :            : 
    2071                 :            : /* Keep these checks in ascending code order.  */
    2072                 :            : #define RECORD_OR_UNION_CODE_P(T)       \
    2073                 :            :   ((T) == RECORD_TYPE || (T) == UNION_TYPE)
    2074                 :            : #define OVERLOAD_TYPE_P(T) \
    2075                 :            :   (CLASS_TYPE_P (T) || TREE_CODE (T) == ENUMERAL_TYPE)
    2076                 :            : 
    2077                 :            : /* True if this type is dependent.  This predicate is only valid if
    2078                 :            :    TYPE_DEPENDENT_P_VALID is true.  */
    2079                 :            : #define TYPE_DEPENDENT_P(NODE) TYPE_LANG_FLAG_0 (NODE)
    2080                 :            : 
    2081                 :            : /* True if dependent_type_p has been called for this type, with the
    2082                 :            :    result that TYPE_DEPENDENT_P is valid.  */
    2083                 :            : #define TYPE_DEPENDENT_P_VALID(NODE) TYPE_LANG_FLAG_6(NODE)
    2084                 :            : 
    2085                 :            : /* Nonzero if this type is const-qualified.  */
    2086                 :            : #define CP_TYPE_CONST_P(NODE)                           \
    2087                 :            :   ((cp_type_quals (NODE) & TYPE_QUAL_CONST) != 0)
    2088                 :            : 
    2089                 :            : /* Nonzero if this type is volatile-qualified.  */
    2090                 :            : #define CP_TYPE_VOLATILE_P(NODE)                        \
    2091                 :            :   ((cp_type_quals (NODE) & TYPE_QUAL_VOLATILE) != 0)
    2092                 :            : 
    2093                 :            : /* Nonzero if this type is restrict-qualified.  */
    2094                 :            : #define CP_TYPE_RESTRICT_P(NODE)                        \
    2095                 :            :   ((cp_type_quals (NODE) & TYPE_QUAL_RESTRICT) != 0)
    2096                 :            : 
    2097                 :            : /* Nonzero if this type is const-qualified, but not
    2098                 :            :    volatile-qualified.  Other qualifiers are ignored.  This macro is
    2099                 :            :    used to test whether or not it is OK to bind an rvalue to a
    2100                 :            :    reference.  */
    2101                 :            : #define CP_TYPE_CONST_NON_VOLATILE_P(NODE)                              \
    2102                 :            :   ((cp_type_quals (NODE) & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE))  \
    2103                 :            :    == TYPE_QUAL_CONST)
    2104                 :            : 
    2105                 :            : #define FUNCTION_ARG_CHAIN(NODE) \
    2106                 :            :   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (NODE)))
    2107                 :            : 
    2108                 :            : /* Given a FUNCTION_DECL, returns the first TREE_LIST out of TYPE_ARG_TYPES
    2109                 :            :    which refers to a user-written parameter.  */
    2110                 :            : #define FUNCTION_FIRST_USER_PARMTYPE(NODE) \
    2111                 :            :   skip_artificial_parms_for ((NODE), TYPE_ARG_TYPES (TREE_TYPE (NODE)))
    2112                 :            : 
    2113                 :            : /* Similarly, but for DECL_ARGUMENTS.  */
    2114                 :            : #define FUNCTION_FIRST_USER_PARM(NODE) \
    2115                 :            :   skip_artificial_parms_for ((NODE), DECL_ARGUMENTS (NODE))
    2116                 :            : 
    2117                 :            : /* Nonzero iff TYPE is derived from PARENT. Ignores accessibility and
    2118                 :            :    ambiguity issues.  */
    2119                 :            : #define DERIVED_FROM_P(PARENT, TYPE) \
    2120                 :            :   (lookup_base ((TYPE), (PARENT), ba_any, NULL, tf_none) != NULL_TREE)
    2121                 :            : 
    2122                 :            : /* Gives the visibility specification for a class type.  */
    2123                 :            : #define CLASSTYPE_VISIBILITY(TYPE)              \
    2124                 :            :         DECL_VISIBILITY (TYPE_MAIN_DECL (TYPE))
    2125                 :            : #define CLASSTYPE_VISIBILITY_SPECIFIED(TYPE)    \
    2126                 :            :         DECL_VISIBILITY_SPECIFIED (TYPE_MAIN_DECL (TYPE))
    2127                 :            : 
    2128                 :            : struct GTY (()) tree_pair_s {
    2129                 :            :   tree purpose;
    2130                 :            :   tree value;
    2131                 :            : };
    2132                 :            : typedef tree_pair_s *tree_pair_p;
    2133                 :            : 
    2134                 :            : /* This structure provides additional information above and beyond
    2135                 :            :    what is provide in the ordinary tree_type.  In the past, we used it
    2136                 :            :    for the types of class types, template parameters types, typename
    2137                 :            :    types, and so forth.  However, there can be many (tens to hundreds
    2138                 :            :    of thousands) of template parameter types in a compilation, and
    2139                 :            :    there's no need for this additional information in that case.
    2140                 :            :    Therefore, we now use this data structure only for class types.
    2141                 :            : 
    2142                 :            :    In the past, it was thought that there would be relatively few
    2143                 :            :    class types.  However, in the presence of heavy use of templates,
    2144                 :            :    many (i.e., thousands) of classes can easily be generated.
    2145                 :            :    Therefore, we should endeavor to keep the size of this structure to
    2146                 :            :    a minimum.  */
    2147                 :            : struct GTY(()) lang_type {
    2148                 :            :   unsigned char align;
    2149                 :            : 
    2150                 :            :   unsigned has_type_conversion : 1;
    2151                 :            :   unsigned has_copy_ctor : 1;
    2152                 :            :   unsigned has_default_ctor : 1;
    2153                 :            :   unsigned const_needs_init : 1;
    2154                 :            :   unsigned ref_needs_init : 1;
    2155                 :            :   unsigned has_const_copy_assign : 1;
    2156                 :            :   unsigned use_template : 2;
    2157                 :            : 
    2158                 :            :   unsigned has_mutable : 1;
    2159                 :            :   unsigned com_interface : 1;
    2160                 :            :   unsigned non_pod_class : 1;
    2161                 :            :   unsigned nearly_empty_p : 1;
    2162                 :            :   unsigned user_align : 1;
    2163                 :            :   unsigned has_copy_assign : 1;
    2164                 :            :   unsigned has_new : 1;
    2165                 :            :   unsigned has_array_new : 1;
    2166                 :            : 
    2167                 :            :   unsigned gets_delete : 2;
    2168                 :            :   unsigned interface_only : 1;
    2169                 :            :   unsigned interface_unknown : 1;
    2170                 :            :   unsigned contains_empty_class_p : 1;
    2171                 :            :   unsigned anon_aggr : 1;
    2172                 :            :   unsigned non_zero_init : 1;
    2173                 :            :   unsigned empty_p : 1;
    2174                 :            :   /* 32 bits allocated.  */
    2175                 :            : 
    2176                 :            :   unsigned vec_new_uses_cookie : 1;
    2177                 :            :   unsigned declared_class : 1;
    2178                 :            :   unsigned diamond_shaped : 1;
    2179                 :            :   unsigned repeated_base : 1;
    2180                 :            :   unsigned being_defined : 1;
    2181                 :            :   unsigned debug_requested : 1;
    2182                 :            :   unsigned fields_readonly : 1;
    2183                 :            :   unsigned ptrmemfunc_flag : 1;
    2184                 :            : 
    2185                 :            :   unsigned lazy_default_ctor : 1;
    2186                 :            :   unsigned lazy_copy_ctor : 1;
    2187                 :            :   unsigned lazy_copy_assign : 1;
    2188                 :            :   unsigned lazy_destructor : 1;
    2189                 :            :   unsigned has_const_copy_ctor : 1;
    2190                 :            :   unsigned has_complex_copy_ctor : 1;
    2191                 :            :   unsigned has_complex_copy_assign : 1;
    2192                 :            :   unsigned non_aggregate : 1;
    2193                 :            : 
    2194                 :            :   unsigned has_complex_dflt : 1;
    2195                 :            :   unsigned has_list_ctor : 1;
    2196                 :            :   unsigned non_std_layout : 1;
    2197                 :            :   unsigned is_literal : 1;
    2198                 :            :   unsigned lazy_move_ctor : 1;
    2199                 :            :   unsigned lazy_move_assign : 1;
    2200                 :            :   unsigned has_complex_move_ctor : 1;
    2201                 :            :   unsigned has_complex_move_assign : 1;
    2202                 :            : 
    2203                 :            :   unsigned has_constexpr_ctor : 1;
    2204                 :            :   unsigned unique_obj_representations : 1;
    2205                 :            :   unsigned unique_obj_representations_set : 1;
    2206                 :            : 
    2207                 :            :   /* When adding a flag here, consider whether or not it ought to
    2208                 :            :      apply to a template instance if it applies to the template.  If
    2209                 :            :      so, make sure to copy it in instantiate_class_template!  */
    2210                 :            : 
    2211                 :            :   /* There are some bits left to fill out a 32-bit word.  Keep track
    2212                 :            :      of this by updating the size of this bitfield whenever you add or
    2213                 :            :      remove a flag.  */
    2214                 :            :   unsigned dummy : 5;
    2215                 :            : 
    2216                 :            :   tree primary_base;
    2217                 :            :   vec<tree_pair_s, va_gc> *vcall_indices;
    2218                 :            :   tree vtables;
    2219                 :            :   tree typeinfo_var;
    2220                 :            :   vec<tree, va_gc> *vbases;
    2221                 :            :   binding_table nested_udts;
    2222                 :            :   tree as_base;
    2223                 :            :   vec<tree, va_gc> *pure_virtuals;
    2224                 :            :   tree friend_classes;
    2225                 :            :   vec<tree, va_gc> * GTY((reorder ("resort_type_member_vec"))) members;
    2226                 :            :   tree key_method;
    2227                 :            :   tree decl_list;
    2228                 :            :   tree befriending_classes;
    2229                 :            :   /* In a RECORD_TYPE, information specific to Objective-C++, such
    2230                 :            :      as a list of adopted protocols or a pointer to a corresponding
    2231                 :            :      @interface.  See objc/objc-act.h for details.  */
    2232                 :            :   tree objc_info;
    2233                 :            :   /* FIXME reuse another field?  */
    2234                 :            :   tree lambda_expr;
    2235                 :            : };
    2236                 :            : 
    2237                 :            : /* We used to have a variant type for lang_type.  Keep the name of the
    2238                 :            :    checking accessor for the sole survivor.  */
    2239                 :            : #define LANG_TYPE_CLASS_CHECK(NODE) (TYPE_LANG_SPECIFIC (NODE))
    2240                 :            : 
    2241                 :            : /* Nonzero for _CLASSTYPE means that operator delete is defined.  */
    2242                 :            : #define TYPE_GETS_DELETE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->gets_delete)
    2243                 :            : #define TYPE_GETS_REG_DELETE(NODE) (TYPE_GETS_DELETE (NODE) & 1)
    2244                 :            : 
    2245                 :            : /* Nonzero if `new NODE[x]' should cause the allocation of extra
    2246                 :            :    storage to indicate how many array elements are in use.  */
    2247                 :            : #define TYPE_VEC_NEW_USES_COOKIE(NODE)                  \
    2248                 :            :   (CLASS_TYPE_P (NODE)                                  \
    2249                 :            :    && LANG_TYPE_CLASS_CHECK (NODE)->vec_new_uses_cookie)
    2250                 :            : 
    2251                 :            : /* Nonzero means that this _CLASSTYPE node defines ways of converting
    2252                 :            :    itself to other types.  */
    2253                 :            : #define TYPE_HAS_CONVERSION(NODE) \
    2254                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->has_type_conversion)
    2255                 :            : 
    2256                 :            : /* Nonzero means that NODE (a class type) has a default constructor --
    2257                 :            :    but that it has not yet been declared.  */
    2258                 :            : #define CLASSTYPE_LAZY_DEFAULT_CTOR(NODE) \
    2259                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_default_ctor)
    2260                 :            : 
    2261                 :            : /* Nonzero means that NODE (a class type) has a copy constructor --
    2262                 :            :    but that it has not yet been declared.  */
    2263                 :            : #define CLASSTYPE_LAZY_COPY_CTOR(NODE) \
    2264                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_copy_ctor)
    2265                 :            : 
    2266                 :            : /* Nonzero means that NODE (a class type) has a move constructor --
    2267                 :            :    but that it has not yet been declared.  */
    2268                 :            : #define CLASSTYPE_LAZY_MOVE_CTOR(NODE) \
    2269                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_move_ctor)
    2270                 :            : 
    2271                 :            : /* Nonzero means that NODE (a class type) has an assignment operator
    2272                 :            :    -- but that it has not yet been declared.  */
    2273                 :            : #define CLASSTYPE_LAZY_COPY_ASSIGN(NODE) \
    2274                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_copy_assign)
    2275                 :            : 
    2276                 :            : /* Nonzero means that NODE (a class type) has an assignment operator
    2277                 :            :    -- but that it has not yet been declared.  */
    2278                 :            : #define CLASSTYPE_LAZY_MOVE_ASSIGN(NODE) \
    2279                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_move_assign)
    2280                 :            : 
    2281                 :            : /* Nonzero means that NODE (a class type) has a destructor -- but that
    2282                 :            :    it has not yet been declared.  */
    2283                 :            : #define CLASSTYPE_LAZY_DESTRUCTOR(NODE) \
    2284                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_destructor)
    2285                 :            : 
    2286                 :            : /* Nonzero means that NODE (a class type) is final */
    2287                 :            : #define CLASSTYPE_FINAL(NODE) \
    2288                 :            :   TYPE_FINAL_P (NODE)
    2289                 :            : 
    2290                 :            : 
    2291                 :            : /* Nonzero means that this _CLASSTYPE node overloads operator=(X&).  */
    2292                 :            : #define TYPE_HAS_COPY_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_copy_assign)
    2293                 :            : 
    2294                 :            : /* True iff the class type NODE has an "operator =" whose parameter
    2295                 :            :    has a parameter of type "const X&".  */
    2296                 :            : #define TYPE_HAS_CONST_COPY_ASSIGN(NODE) \
    2297                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->has_const_copy_assign)
    2298                 :            : 
    2299                 :            : /* Nonzero means that this _CLASSTYPE node has an X(X&) constructor.  */
    2300                 :            : #define TYPE_HAS_COPY_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_copy_ctor)
    2301                 :            : #define TYPE_HAS_CONST_COPY_CTOR(NODE) \
    2302                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->has_const_copy_ctor)
    2303                 :            : 
    2304                 :            : /* Nonzero if this class has an X(initializer_list<T>) constructor.  */
    2305                 :            : #define TYPE_HAS_LIST_CTOR(NODE) \
    2306                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->has_list_ctor)
    2307                 :            : 
    2308                 :            : /* Nonzero if this class has a constexpr constructor other than a copy/move
    2309                 :            :    constructor.  Note that a class can have constexpr constructors for
    2310                 :            :    static initialization even if it isn't a literal class.  */
    2311                 :            : #define TYPE_HAS_CONSTEXPR_CTOR(NODE) \
    2312                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->has_constexpr_ctor)
    2313                 :            : 
    2314                 :            : /* Nonzero if this class defines an overloaded operator new.  (An
    2315                 :            :    operator new [] doesn't count.)  */
    2316                 :            : #define TYPE_HAS_NEW_OPERATOR(NODE) \
    2317                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->has_new)
    2318                 :            : 
    2319                 :            : /* Nonzero if this class defines an overloaded operator new[].  */
    2320                 :            : #define TYPE_HAS_ARRAY_NEW_OPERATOR(NODE) \
    2321                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->has_array_new)
    2322                 :            : 
    2323                 :            : /* Nonzero means that this type is being defined.  I.e., the left brace
    2324                 :            :    starting the definition of this type has been seen.  */
    2325                 :            : #define TYPE_BEING_DEFINED(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->being_defined)
    2326                 :            : 
    2327                 :            : /* Nonzero means that this type is either complete or being defined, so we
    2328                 :            :    can do lookup in it.  */
    2329                 :            : #define COMPLETE_OR_OPEN_TYPE_P(NODE) \
    2330                 :            :   (COMPLETE_TYPE_P (NODE) || (CLASS_TYPE_P (NODE) && TYPE_BEING_DEFINED (NODE)))
    2331                 :            : 
    2332                 :            : /* Mark bits for repeated base checks.  */
    2333                 :            : #define TYPE_MARKED_P(NODE) TREE_LANG_FLAG_6 (TYPE_CHECK (NODE))
    2334                 :            : 
    2335                 :            : /* Nonzero if the class NODE has multiple paths to the same (virtual)
    2336                 :            :    base object.  */
    2337                 :            : #define CLASSTYPE_DIAMOND_SHAPED_P(NODE) \
    2338                 :            :   (LANG_TYPE_CLASS_CHECK(NODE)->diamond_shaped)
    2339                 :            : 
    2340                 :            : /* Nonzero if the class NODE has multiple instances of the same base
    2341                 :            :    type.  */
    2342                 :            : #define CLASSTYPE_REPEATED_BASE_P(NODE) \
    2343                 :            :   (LANG_TYPE_CLASS_CHECK(NODE)->repeated_base)
    2344                 :            : 
    2345                 :            : /* The member function with which the vtable will be emitted:
    2346                 :            :    the first noninline non-pure-virtual member function.  NULL_TREE
    2347                 :            :    if there is no key function or if this is a class template */
    2348                 :            : #define CLASSTYPE_KEY_METHOD(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->key_method)
    2349                 :            : 
    2350                 :            : /* Vector of members.  During definition, it is unordered and only
    2351                 :            :    member functions are present.  After completion it is sorted and
    2352                 :            :    contains both member functions and non-functions.  STAT_HACK is
    2353                 :            :    involved to preserve oneslot per name invariant.  */
    2354                 :            : #define CLASSTYPE_MEMBER_VEC(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->members)
    2355                 :            : 
    2356                 :            : /* For class templates, this is a TREE_LIST of all member data,
    2357                 :            :    functions, types, and friends in the order of declaration.
    2358                 :            :    The TREE_PURPOSE of each TREE_LIST is NULL_TREE for a friend,
    2359                 :            :    and the RECORD_TYPE for the class template otherwise.  */
    2360                 :            : #define CLASSTYPE_DECL_LIST(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->decl_list)
    2361                 :            : 
    2362                 :            : /* A FUNCTION_DECL or OVERLOAD for the constructors for NODE.  These
    2363                 :            :    are the constructors that take an in-charge parameter.  */
    2364                 :            : #define CLASSTYPE_CONSTRUCTORS(NODE) \
    2365                 :            :   (get_class_binding_direct (NODE, ctor_identifier))
    2366                 :            : 
    2367                 :            : /* A FUNCTION_DECL for the destructor for NODE.  This is the
    2368                 :            :    destructors that take an in-charge parameter.  If
    2369                 :            :    CLASSTYPE_LAZY_DESTRUCTOR is true, then this entry will be NULL
    2370                 :            :    until the destructor is created with lazily_declare_fn.  */
    2371                 :            : #define CLASSTYPE_DESTRUCTOR(NODE) \
    2372                 :            :   (get_class_binding_direct (NODE, dtor_identifier))
    2373                 :            : 
    2374                 :            : /* A dictionary of the nested user-defined-types (class-types, or enums)
    2375                 :            :    found within this class.  This table includes nested member class
    2376                 :            :    templates.  */
    2377                 :            : #define CLASSTYPE_NESTED_UTDS(NODE) \
    2378                 :            :    (LANG_TYPE_CLASS_CHECK (NODE)->nested_udts)
    2379                 :            : 
    2380                 :            : /* Nonzero if NODE has a primary base class, i.e., a base class with
    2381                 :            :    which it shares the virtual function table pointer.  */
    2382                 :            : #define CLASSTYPE_HAS_PRIMARY_BASE_P(NODE) \
    2383                 :            :   (CLASSTYPE_PRIMARY_BINFO (NODE) != NULL_TREE)
    2384                 :            : 
    2385                 :            : /* If non-NULL, this is the binfo for the primary base class, i.e.,
    2386                 :            :    the base class which contains the virtual function table pointer
    2387                 :            :    for this class.  */
    2388                 :            : #define CLASSTYPE_PRIMARY_BINFO(NODE) \
    2389                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->primary_base)
    2390                 :            : 
    2391                 :            : /* A vector of BINFOs for the direct and indirect virtual base classes
    2392                 :            :    that this type uses in a post-order depth-first left-to-right
    2393                 :            :    order.  (In other words, these bases appear in the order that they
    2394                 :            :    should be initialized.)  */
    2395                 :            : #define CLASSTYPE_VBASECLASSES(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->vbases)
    2396                 :            : 
    2397                 :            : /* The type corresponding to NODE when NODE is used as a base class,
    2398                 :            :    i.e., NODE without virtual base classes or tail padding.  */
    2399                 :            : #define CLASSTYPE_AS_BASE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->as_base)
    2400                 :            : 
    2401                 :            : /* True iff NODE is the CLASSTYPE_AS_BASE version of some type.  */
    2402                 :            : #define IS_FAKE_BASE_TYPE(NODE)                                 \
    2403                 :            :   (TREE_CODE (NODE) == RECORD_TYPE                              \
    2404                 :            :    && TYPE_CONTEXT (NODE) && CLASS_TYPE_P (TYPE_CONTEXT (NODE)) \
    2405                 :            :    && CLASSTYPE_AS_BASE (TYPE_CONTEXT (NODE)) == (NODE))
    2406                 :            : 
    2407                 :            : /* These are the size and alignment of the type without its virtual
    2408                 :            :    base classes, for when we use this type as a base itself.  */
    2409                 :            : #define CLASSTYPE_SIZE(NODE) TYPE_SIZE (CLASSTYPE_AS_BASE (NODE))
    2410                 :            : #define CLASSTYPE_SIZE_UNIT(NODE) TYPE_SIZE_UNIT (CLASSTYPE_AS_BASE (NODE))
    2411                 :            : #define CLASSTYPE_ALIGN(NODE) TYPE_ALIGN (CLASSTYPE_AS_BASE (NODE))
    2412                 :            : #define CLASSTYPE_USER_ALIGN(NODE) TYPE_USER_ALIGN (CLASSTYPE_AS_BASE (NODE))
    2413                 :            : 
    2414                 :            : /* The alignment of NODE, without its virtual bases, in bytes.  */
    2415                 :            : #define CLASSTYPE_ALIGN_UNIT(NODE) \
    2416                 :            :   (CLASSTYPE_ALIGN (NODE) / BITS_PER_UNIT)
    2417                 :            : 
    2418                 :            : /* A vec<tree> of virtual functions which cannot be inherited by
    2419                 :            :    derived classes.  When deriving from this type, the derived
    2420                 :            :    class must provide its own definition for each of these functions.  */
    2421                 :            : #define CLASSTYPE_PURE_VIRTUALS(NODE) \
    2422                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->pure_virtuals)
    2423                 :            : 
    2424                 :            : /* Nonzero means that this type is an abstract class type.  */
    2425                 :            : #define ABSTRACT_CLASS_TYPE_P(NODE) \
    2426                 :            :   (CLASS_TYPE_P (NODE) && CLASSTYPE_PURE_VIRTUALS(NODE))
    2427                 :            : 
    2428                 :            : /* Nonzero means that this type has an X() constructor.  */
    2429                 :            : #define TYPE_HAS_DEFAULT_CONSTRUCTOR(NODE) \
    2430                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->has_default_ctor)
    2431                 :            : 
    2432                 :            : /* Nonzero means that this type contains a mutable member.  */
    2433                 :            : #define CLASSTYPE_HAS_MUTABLE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_mutable)
    2434                 :            : #define TYPE_HAS_MUTABLE_P(NODE) (cp_has_mutable_p (NODE))
    2435                 :            : 
    2436                 :            : /* Nonzero means that this class type is not POD for the purpose of layout
    2437                 :            :    (as defined in the ABI).  This is different from the language's POD.  */
    2438                 :            : #define CLASSTYPE_NON_LAYOUT_POD_P(NODE) \
    2439                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->non_pod_class)
    2440                 :            : 
    2441                 :            : /* Nonzero means that this class type is a non-standard-layout class.  */
    2442                 :            : #define CLASSTYPE_NON_STD_LAYOUT(NODE) \
    2443                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->non_std_layout)
    2444                 :            : 
    2445                 :            : /* Nonzero means that this class type does have unique object
    2446                 :            :    representations.  */
    2447                 :            : #define CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS(NODE) \
    2448                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->unique_obj_representations)
    2449                 :            : 
    2450                 :            : /* Nonzero means that this class type has
    2451                 :            :    CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS computed.  */
    2452                 :            : #define CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET(NODE) \
    2453                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->unique_obj_representations_set)
    2454                 :            : 
    2455                 :            : /* Nonzero means that this class contains pod types whose default
    2456                 :            :    initialization is not a zero initialization (namely, pointers to
    2457                 :            :    data members).  */
    2458                 :            : #define CLASSTYPE_NON_ZERO_INIT_P(NODE) \
    2459                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->non_zero_init)
    2460                 :            : 
    2461                 :            : /* Nonzero if this class is "empty" in the sense of the C++ ABI.  */
    2462                 :            : #define CLASSTYPE_EMPTY_P(NODE) \
    2463                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->empty_p)
    2464                 :            : 
    2465                 :            : /* Nonzero if this class is "nearly empty", i.e., contains only a
    2466                 :            :    virtual function table pointer.  */
    2467                 :            : #define CLASSTYPE_NEARLY_EMPTY_P(NODE) \
    2468                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->nearly_empty_p)
    2469                 :            : 
    2470                 :            : /* Nonzero if this class contains an empty subobject.  */
    2471                 :            : #define CLASSTYPE_CONTAINS_EMPTY_CLASS_P(NODE) \
    2472                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->contains_empty_class_p)
    2473                 :            : 
    2474                 :            : /* A list of class types of which this type is a friend.  The
    2475                 :            :    TREE_VALUE is normally a TYPE, but will be a TEMPLATE_DECL in the
    2476                 :            :    case of a template friend.  */
    2477                 :            : #define CLASSTYPE_FRIEND_CLASSES(NODE) \
    2478                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->friend_classes)
    2479                 :            : 
    2480                 :            : /* A list of the classes which grant friendship to this class.  */
    2481                 :            : #define CLASSTYPE_BEFRIENDING_CLASSES(NODE) \
    2482                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->befriending_classes)
    2483                 :            : 
    2484                 :            : /* The associated LAMBDA_EXPR that made this class.  */
    2485                 :            : #define CLASSTYPE_LAMBDA_EXPR(NODE) \
    2486                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->lambda_expr)
    2487                 :            : /* The extra mangling scope for this closure type.  */
    2488                 :            : #define LAMBDA_TYPE_EXTRA_SCOPE(NODE) \
    2489                 :            :   (LAMBDA_EXPR_EXTRA_SCOPE (CLASSTYPE_LAMBDA_EXPR (NODE)))
    2490                 :            : 
    2491                 :            : /* Say whether this node was declared as a "class" or a "struct".  */
    2492                 :            : #define CLASSTYPE_DECLARED_CLASS(NODE) \
    2493                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->declared_class)
    2494                 :            : 
    2495                 :            : /* Nonzero if this class has const members
    2496                 :            :    which have no specified initialization.  */
    2497                 :            : #define CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE)       \
    2498                 :            :   (TYPE_LANG_SPECIFIC (NODE)                            \
    2499                 :            :    ? LANG_TYPE_CLASS_CHECK (NODE)->const_needs_init : 0)
    2500                 :            : #define SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE, VALUE) \
    2501                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->const_needs_init = (VALUE))
    2502                 :            : 
    2503                 :            : /* Nonzero if this class has ref members
    2504                 :            :    which have no specified initialization.  */
    2505                 :            : #define CLASSTYPE_REF_FIELDS_NEED_INIT(NODE)            \
    2506                 :            :   (TYPE_LANG_SPECIFIC (NODE)                            \
    2507                 :            :    ? LANG_TYPE_CLASS_CHECK (NODE)->ref_needs_init : 0)
    2508                 :            : #define SET_CLASSTYPE_REF_FIELDS_NEED_INIT(NODE, VALUE) \
    2509                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->ref_needs_init = (VALUE))
    2510                 :            : 
    2511                 :            : /* Nonzero if this class is included from a header file which employs
    2512                 :            :    `#pragma interface', and it is not included in its implementation file.  */
    2513                 :            : #define CLASSTYPE_INTERFACE_ONLY(NODE) \
    2514                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->interface_only)
    2515                 :            : 
    2516                 :            : /* True if we have already determined whether or not vtables, VTTs,
    2517                 :            :    typeinfo, and other similar per-class data should be emitted in
    2518                 :            :    this translation unit.  This flag does not indicate whether or not
    2519                 :            :    these items should be emitted; it only indicates that we know one
    2520                 :            :    way or the other.  */
    2521                 :            : #define CLASSTYPE_INTERFACE_KNOWN(NODE) \
    2522                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown == 0)
    2523                 :            : /* The opposite of CLASSTYPE_INTERFACE_KNOWN.  */
    2524                 :            : #define CLASSTYPE_INTERFACE_UNKNOWN(NODE) \
    2525                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown)
    2526                 :            : 
    2527                 :            : #define SET_CLASSTYPE_INTERFACE_UNKNOWN_X(NODE,X) \
    2528                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = !!(X))
    2529                 :            : #define SET_CLASSTYPE_INTERFACE_UNKNOWN(NODE) \
    2530                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 1)
    2531                 :            : #define SET_CLASSTYPE_INTERFACE_KNOWN(NODE) \
    2532                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->interface_unknown = 0)
    2533                 :            : 
    2534                 :            : /* Nonzero if a _DECL node requires us to output debug info for this class.  */
    2535                 :            : #define CLASSTYPE_DEBUG_REQUESTED(NODE) \
    2536                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->debug_requested)
    2537                 :            : 
    2538                 :            : /* Additional macros for inheritance information.  */
    2539                 :            : 
    2540                 :            : /* Nonzero means that this class is on a path leading to a new vtable.  */
    2541                 :            : #define BINFO_VTABLE_PATH_MARKED(NODE) BINFO_FLAG_1 (NODE)
    2542                 :            : 
    2543                 :            : /* Nonzero means B (a BINFO) has its own vtable.  Any copies will not
    2544                 :            :    have this flag set.  */
    2545                 :            : #define BINFO_NEW_VTABLE_MARKED(B) (BINFO_FLAG_2 (B))
    2546                 :            : 
    2547                 :            : /* Compare a BINFO_TYPE with another type for equality.  For a binfo,
    2548                 :            :    this is functionally equivalent to using same_type_p, but
    2549                 :            :    measurably faster.  At least one of the arguments must be a
    2550                 :            :    BINFO_TYPE.  The other can be a BINFO_TYPE or a regular type.  If
    2551                 :            :    BINFO_TYPE(T) ever stops being the main variant of the class the
    2552                 :            :    binfo is for, this macro must change.  */
    2553                 :            : #define SAME_BINFO_TYPE_P(A, B) ((A) == (B))
    2554                 :            : 
    2555                 :            : /* Any subobject that needs a new vtable must have a vptr and must not
    2556                 :            :    be a non-virtual primary base (since it would then use the vtable from a
    2557                 :            :    derived class and never become non-primary.)  */
    2558                 :            : #define SET_BINFO_NEW_VTABLE_MARKED(B)                                   \
    2559                 :            :   (BINFO_NEW_VTABLE_MARKED (B) = 1,                                      \
    2560                 :            :    gcc_assert (!BINFO_PRIMARY_P (B) || BINFO_VIRTUAL_P (B)),             \
    2561                 :            :    gcc_assert (TYPE_VFIELD (BINFO_TYPE (B))))
    2562                 :            : 
    2563                 :            : /* Nonzero if this binfo is for a dependent base - one that should not
    2564                 :            :    be searched.  */
    2565                 :            : #define BINFO_DEPENDENT_BASE_P(NODE) BINFO_FLAG_3 (NODE)
    2566                 :            : 
    2567                 :            : /* Nonzero if this binfo has lost its primary base binfo (because that
    2568                 :            :    is a nearly-empty virtual base that has been taken by some other
    2569                 :            :    base in the complete hierarchy.  */
    2570                 :            : #define BINFO_LOST_PRIMARY_P(NODE) BINFO_FLAG_4 (NODE)
    2571                 :            : 
    2572                 :            : /* Nonzero if this BINFO is a primary base class.  */
    2573                 :            : #define BINFO_PRIMARY_P(NODE) BINFO_FLAG_5(NODE)
    2574                 :            : 
    2575                 :            : /* A vec<tree_pair_s> of the vcall indices associated with the class
    2576                 :            :    NODE.  The PURPOSE of each element is a FUNCTION_DECL for a virtual
    2577                 :            :    function.  The VALUE is the index into the virtual table where the
    2578                 :            :    vcall offset for that function is stored, when NODE is a virtual
    2579                 :            :    base.  */
    2580                 :            : #define CLASSTYPE_VCALL_INDICES(NODE) \
    2581                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->vcall_indices)
    2582                 :            : 
    2583                 :            : /* The various vtables for the class NODE.  The primary vtable will be
    2584                 :            :    first, followed by the construction vtables and VTT, if any.  */
    2585                 :            : #define CLASSTYPE_VTABLES(NODE) \
    2586                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->vtables)
    2587                 :            : 
    2588                 :            : /* The std::type_info variable representing this class, or NULL if no
    2589                 :            :    such variable has been created.  This field is only set for the
    2590                 :            :    TYPE_MAIN_VARIANT of the class.  */
    2591                 :            : #define CLASSTYPE_TYPEINFO_VAR(NODE) \
    2592                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var)
    2593                 :            : 
    2594                 :            : /* Accessor macros for the BINFO_VIRTUALS list.  */
    2595                 :            : 
    2596                 :            : /* The number of bytes by which to adjust the `this' pointer when
    2597                 :            :    calling this virtual function.  Subtract this value from the this
    2598                 :            :    pointer. Always non-NULL, might be constant zero though.  */
    2599                 :            : #define BV_DELTA(NODE) (TREE_PURPOSE (NODE))
    2600                 :            : 
    2601                 :            : /* If non-NULL, the vtable index at which to find the vcall offset
    2602                 :            :    when calling this virtual function.  Add the value at that vtable
    2603                 :            :    index to the this pointer.  */
    2604                 :            : #define BV_VCALL_INDEX(NODE) (TREE_TYPE (NODE))
    2605                 :            : 
    2606                 :            : /* The function to call.  */
    2607                 :            : #define BV_FN(NODE) (TREE_VALUE (NODE))
    2608                 :            : 
    2609                 :            : /* Whether or not this entry is for a lost primary virtual base.  */
    2610                 :            : #define BV_LOST_PRIMARY(NODE) (TREE_LANG_FLAG_0 (NODE))
    2611                 :            : 
    2612                 :            : /* For FUNCTION_TYPE or METHOD_TYPE, a list of the exceptions that
    2613                 :            :    this type can raise.  Each TREE_VALUE is a _TYPE.  The TREE_VALUE
    2614                 :            :    will be NULL_TREE to indicate a throw specification of `()', or
    2615                 :            :    no exceptions allowed.  For a noexcept specification, TREE_VALUE
    2616                 :            :    is NULL_TREE and TREE_PURPOSE is the constant-expression.  For
    2617                 :            :    a deferred noexcept-specification, TREE_PURPOSE is a DEFERRED_NOEXCEPT
    2618                 :            :    (for templates) or an OVERLOAD list of functions (for implicitly
    2619                 :            :    declared functions).  */
    2620                 :            : #define TYPE_RAISES_EXCEPTIONS(NODE) \
    2621                 :            :   TYPE_LANG_SLOT_1 (FUNC_OR_METHOD_CHECK (NODE))
    2622                 :            : 
    2623                 :            : /* For FUNCTION_TYPE or METHOD_TYPE, return 1 iff it is declared `throw()'
    2624                 :            :    or noexcept(true).  */
    2625                 :            : #define TYPE_NOTHROW_P(NODE) nothrow_spec_p (TYPE_RAISES_EXCEPTIONS (NODE))
    2626                 :            : 
    2627                 :            : /* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept.  This is the
    2628                 :            :    case for things declared noexcept(true) and, with -fnothrow-opt, for
    2629                 :            :    throw() functions.  */
    2630                 :            : #define TYPE_NOEXCEPT_P(NODE) type_noexcept_p (NODE)
    2631                 :            : 
    2632                 :            : /* The binding level associated with the namespace.  */
    2633                 :            : #define NAMESPACE_LEVEL(NODE) \
    2634                 :            :   (LANG_DECL_NS_CHECK (NODE)->level)
    2635                 :            : 
    2636                 :            : /* Discriminator values for lang_decl.  */
    2637                 :            : 
    2638                 :            : enum lang_decl_selector
    2639                 :            : {
    2640                 :            :   lds_min,
    2641                 :            :   lds_fn,
    2642                 :            :   lds_ns,
    2643                 :            :   lds_parm,
    2644                 :            :   lds_decomp
    2645                 :            : };
    2646                 :            : 
    2647                 :            : /* Flags shared by all forms of DECL_LANG_SPECIFIC.
    2648                 :            : 
    2649                 :            :    Some of the flags live here only to make lang_decl_min/fn smaller.  Do
    2650                 :            :    not make this struct larger than 32 bits; instead, make sel smaller.  */
    2651                 :            : 
    2652                 :            : struct GTY(()) lang_decl_base {
    2653                 :            :   /* Larger than necessary for faster access.  */
    2654                 :            :   ENUM_BITFIELD(lang_decl_selector) selector : 16;
    2655                 :            :   ENUM_BITFIELD(languages) language : 1;
    2656                 :            :   unsigned use_template : 2;
    2657                 :            :   unsigned not_really_extern : 1;          /* var or fn */
    2658                 :            :   unsigned initialized_in_class : 1;       /* var or fn */
    2659                 :            :   unsigned threadprivate_or_deleted_p : 1; /* var or fn */
    2660                 :            :   unsigned anticipated_p : 1;              /* fn, type or template */
    2661                 :            :   /* anticipated_p reused as DECL_OMP_PRIVATIZED_MEMBER in var */
    2662                 :            :   unsigned friend_or_tls : 1;              /* var, fn, type or template */
    2663                 :            :   unsigned unknown_bound_p : 1;            /* var */
    2664                 :            :   unsigned odr_used : 1;                   /* var or fn */
    2665                 :            :   unsigned spare : 1;
    2666                 :            :   unsigned concept_p : 1;                  /* applies to vars and functions */
    2667                 :            :   unsigned var_declared_inline_p : 1;      /* var */
    2668                 :            :   unsigned dependent_init_p : 1;           /* var */
    2669                 :            :   /* 2 spare bits */
    2670                 :            : };
    2671                 :            : 
    2672                 :            : /* True for DECL codes which have template info and access.  */
    2673                 :            : #define LANG_DECL_HAS_MIN(NODE)                 \
    2674                 :            :   (VAR_OR_FUNCTION_DECL_P (NODE)                \
    2675                 :            :    || TREE_CODE (NODE) == FIELD_DECL            \
    2676                 :            :    || TREE_CODE (NODE) == CONST_DECL            \
    2677                 :            :    || TREE_CODE (NODE) == TYPE_DECL             \
    2678                 :            :    || TREE_CODE (NODE) == TEMPLATE_DECL         \
    2679                 :            :    || TREE_CODE (NODE) == USING_DECL            \
    2680                 :            :    || TREE_CODE (NODE) == CONCEPT_DECL)
    2681                 :            : 
    2682                 :            : /* DECL_LANG_SPECIFIC for the above codes.  */
    2683                 :            : 
    2684                 :            : struct GTY(()) lang_decl_min {
    2685                 :            :   struct lang_decl_base base;
    2686                 :            : 
    2687                 :            :   /* In a FUNCTION_DECL for which DECL_THUNK_P holds, this is
    2688                 :            :      THUNK_ALIAS.
    2689                 :            :      In a FUNCTION_DECL for which DECL_THUNK_P does not hold,
    2690                 :            :      VAR_DECL, TYPE_DECL, or TEMPLATE_DECL, this is
    2691                 :            :      DECL_TEMPLATE_INFO.  */
    2692                 :            :   tree template_info;
    2693                 :            : 
    2694                 :            :   /* In a DECL_THUNK_P FUNCTION_DECL, this is THUNK_VIRTUAL_OFFSET.
    2695                 :            :      In a lambda-capture proxy VAR_DECL, this is DECL_CAPTURED_VARIABLE.
    2696                 :            :      In a function-scope TREE_STATIC VAR_DECL or IMPLICIT_TYPEDEF_P TYPE_DECL,
    2697                 :            :      this is DECL_DISCRIMINATOR.
    2698                 :            :      Otherwise, in a class-scope DECL, this is DECL_ACCESS.   */
    2699                 :            :   tree access;
    2700                 :            : };
    2701                 :            : 
    2702                 :            : /* Additional DECL_LANG_SPECIFIC information for functions.  */
    2703                 :            : 
    2704                 :            : struct GTY(()) lang_decl_fn {
    2705                 :            :   struct lang_decl_min min;
    2706                 :            : 
    2707                 :            :   /* In a overloaded operator, this is the compressed operator code.  */
    2708                 :            :   unsigned ovl_op_code : 6;
    2709                 :            :   unsigned global_ctor_p : 1;
    2710                 :            :   unsigned global_dtor_p : 1;
    2711                 :            : 
    2712                 :            :   unsigned static_function : 1;
    2713                 :            :   unsigned pure_virtual : 1;
    2714                 :            :   unsigned defaulted_p : 1;
    2715                 :            :   unsigned has_in_charge_parm_p : 1;
    2716                 :            :   unsigned has_vtt_parm_p : 1;
    2717                 :            :   unsigned pending_inline_p : 1;
    2718                 :            :   unsigned nonconverting : 1;
    2719                 :            :   unsigned thunk_p : 1;
    2720                 :            : 
    2721                 :            :   unsigned this_thunk_p : 1;
    2722                 :            :   unsigned hidden_friend_p : 1;
    2723                 :            :   unsigned omp_declare_reduction_p : 1;
    2724                 :            :   unsigned has_dependent_explicit_spec_p : 1;
    2725                 :            :   unsigned immediate_fn_p : 1;
    2726                 :            :   unsigned maybe_deleted : 1;
    2727                 :            :   unsigned coroutine_p : 1;
    2728                 :            : 
    2729                 :            :   unsigned spare : 9;
    2730                 :            : 
    2731                 :            :   /* 32-bits padding on 64-bit host.  */
    2732                 :            : 
    2733                 :            :   /* For a non-thunk function decl, this is a tree list of
    2734                 :            :      friendly classes. For a thunk function decl, it is the
    2735                 :            :      thunked to function decl.  */
    2736                 :            :   tree befriending_classes;
    2737                 :            : 
    2738                 :            :   /* For a non-virtual FUNCTION_DECL, this is
    2739                 :            :      DECL_FRIEND_CONTEXT.  For a virtual FUNCTION_DECL for which
    2740                 :            :      DECL_THIS_THUNK_P does not hold, this is DECL_THUNKS. Both
    2741                 :            :      this pointer and result pointer adjusting thunks are
    2742                 :            :      chained here.  This pointer thunks to return pointer thunks
    2743                 :            :      will be chained on the return pointer thunk.  */
    2744                 :            :   tree context;
    2745                 :            : 
    2746                 :            :   union lang_decl_u5
    2747                 :            :   {
    2748                 :            :     /* In a non-thunk FUNCTION_DECL or TEMPLATE_DECL, this is
    2749                 :            :        DECL_CLONED_FUNCTION.  */
    2750                 :            :     tree GTY ((tag ("0"))) cloned_function;
    2751                 :            : 
    2752                 :            :     /* In a FUNCTION_DECL for which THUNK_P holds this is the
    2753                 :            :        THUNK_FIXED_OFFSET.  */
    2754                 :            :     HOST_WIDE_INT GTY ((tag ("1"))) fixed_offset;
    2755                 :            :   } GTY ((desc ("%1.thunk_p"))) u5;
    2756                 :            : 
    2757                 :            :   union lang_decl_u3
    2758                 :            :   {
    2759                 :            :     struct cp_token_cache * GTY ((tag ("1"))) pending_inline_info;
    2760                 :            :     tree GTY ((tag ("0"))) saved_auto_return_type;
    2761                 :            :   } GTY ((desc ("%1.pending_inline_p"))) u;
    2762                 :            : 
    2763                 :            : };
    2764                 :            : 
    2765                 :            : /* DECL_LANG_SPECIFIC for namespaces.  */
    2766                 :            : 
    2767                 :            : struct GTY(()) lang_decl_ns {
    2768                 :            :   struct lang_decl_base base;
    2769                 :            :   cp_binding_level *level;
    2770                 :            : 
    2771                 :            :   /* Inline children.  These need to be va_gc, because of PCH.  */
    2772                 :            :   vec<tree, va_gc> *inlinees;
    2773                 :            : 
    2774                 :            :   /* Hash table of bound decls. It'd be nice to have this inline, but
    2775                 :            :      as the hash_map has a dtor, we can't then put this struct into a
    2776                 :            :      union (until moving to c++11).  */
    2777                 :            :   hash_table<named_decl_hash> *bindings;
    2778                 :            : };
    2779                 :            : 
    2780                 :            : /* DECL_LANG_SPECIFIC for parameters.  */
    2781                 :            : 
    2782                 :            : struct GTY(()) lang_decl_parm {
    2783                 :            :   struct lang_decl_base base;
    2784                 :            :   int level;
    2785                 :            :   int index;
    2786                 :            : };
    2787                 :            : 
    2788                 :            : /* Additional DECL_LANG_SPECIFIC information for structured bindings.  */
    2789                 :            : 
    2790                 :            : struct GTY(()) lang_decl_decomp {
    2791                 :            :   struct lang_decl_min min;
    2792                 :            :   /* The artificial underlying "e" variable of the structured binding
    2793                 :            :      variable.  */
    2794                 :            :   tree base;
    2795                 :            : };
    2796                 :            : 
    2797                 :            : /* DECL_LANG_SPECIFIC for all types.  It would be nice to just make this a
    2798                 :            :    union rather than a struct containing a union as its only field, but
    2799                 :            :    tree.h declares it as a struct.  */
    2800                 :            : 
    2801                 :            : struct GTY(()) lang_decl {
    2802                 :            :   union GTY((desc ("%h.base.selector"))) lang_decl_u {
    2803                 :            :      /* Nothing of only the base type exists.  */
    2804                 :            :     struct lang_decl_base GTY ((default)) base;
    2805                 :            :     struct lang_decl_min GTY((tag ("lds_min"))) min;
    2806                 :            :     struct lang_decl_fn GTY ((tag ("lds_fn"))) fn;
    2807                 :            :     struct lang_decl_ns GTY((tag ("lds_ns"))) ns;
    2808                 :            :     struct lang_decl_parm GTY((tag ("lds_parm"))) parm;
    2809                 :            :     struct lang_decl_decomp GTY((tag ("lds_decomp"))) decomp;
    2810                 :            :   } u;
    2811                 :            : };
    2812                 :            : 
    2813                 :            : /* Looks through a template (if present) to find what it declares.  */
    2814                 :            : #define STRIP_TEMPLATE(NODE) \
    2815                 :            :   (TREE_CODE (NODE) == TEMPLATE_DECL ? DECL_TEMPLATE_RESULT (NODE) : NODE)
    2816                 :            : 
    2817                 :            : #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
    2818                 :            : 
    2819                 :            : #define LANG_DECL_MIN_CHECK(NODE) __extension__                 \
    2820                 :            : ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE);            \
    2821                 :            :    if (!LANG_DECL_HAS_MIN (NODE))                               \
    2822                 :            :      lang_check_failed (__FILE__, __LINE__, __FUNCTION__);      \
    2823                 :            :    &lt->u.min; })
    2824                 :            : 
    2825                 :            : /* We want to be able to check DECL_CONSTRUCTOR_P and such on a function
    2826                 :            :    template, not just on a FUNCTION_DECL.  So when looking for things in
    2827                 :            :    lang_decl_fn, look down through a TEMPLATE_DECL into its result.  */
    2828                 :            : #define LANG_DECL_FN_CHECK(NODE) __extension__                          \
    2829                 :            : ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (STRIP_TEMPLATE (NODE));   \
    2830                 :            :    if (!DECL_DECLARES_FUNCTION_P (NODE)                                 \
    2831                 :            :        || lt->u.base.selector != lds_fn)                             \
    2832                 :            :      lang_check_failed (__FILE__, __LINE__, __FUNCTION__);              \
    2833                 :            :    &lt->u.fn; })
    2834                 :            : 
    2835                 :            : #define LANG_DECL_NS_CHECK(NODE) __extension__                          \
    2836                 :            : ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE);                    \
    2837                 :            :    if (TREE_CODE (NODE) != NAMESPACE_DECL                               \
    2838                 :            :        || lt->u.base.selector != lds_ns)                             \
    2839                 :            :      lang_check_failed (__FILE__, __LINE__, __FUNCTION__);              \
    2840                 :            :    &lt->u.ns; })
    2841                 :            : 
    2842                 :            : #define LANG_DECL_PARM_CHECK(NODE) __extension__                \
    2843                 :            : ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE);            \
    2844                 :            :   if (TREE_CODE (NODE) != PARM_DECL                             \
    2845                 :            :       || lt->u.base.selector != lds_parm)                    \
    2846                 :            :     lang_check_failed (__FILE__, __LINE__, __FUNCTION__);       \
    2847                 :            :   &lt->u.parm; })
    2848                 :            : 
    2849                 :            : #define LANG_DECL_DECOMP_CHECK(NODE) __extension__              \
    2850                 :            : ({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE);            \
    2851                 :            :   if (!VAR_P (NODE)                                             \
    2852                 :            :       || lt->u.base.selector != lds_decomp)                  \
    2853                 :            :     lang_check_failed (__FILE__, __LINE__, __FUNCTION__);       \
    2854                 :            :   &lt->u.decomp; })
    2855                 :            : 
    2856                 :            : #else
    2857                 :            : 
    2858                 :            : #define LANG_DECL_MIN_CHECK(NODE) \
    2859                 :            :   (&DECL_LANG_SPECIFIC (NODE)->u.min)
    2860                 :            : 
    2861                 :            : #define LANG_DECL_FN_CHECK(NODE) \
    2862                 :            :   (&DECL_LANG_SPECIFIC (STRIP_TEMPLATE (NODE))->u.fn)
    2863                 :            : 
    2864                 :            : #define LANG_DECL_NS_CHECK(NODE) \
    2865                 :            :   (&DECL_LANG_SPECIFIC (NODE)->u.ns)
    2866                 :            : 
    2867                 :            : #define LANG_DECL_PARM_CHECK(NODE) \
    2868                 :            :   (&DECL_LANG_SPECIFIC (NODE)->u.parm)
    2869                 :            : 
    2870                 :            : #define LANG_DECL_DECOMP_CHECK(NODE) \
    2871                 :            :   (&DECL_LANG_SPECIFIC (NODE)->u.decomp)
    2872                 :            : 
    2873                 :            : #endif /* ENABLE_TREE_CHECKING */
    2874                 :            : 
    2875                 :            : /* For a FUNCTION_DECL or a VAR_DECL, the language linkage for the
    2876                 :            :    declaration.  Some entities (like a member function in a local
    2877                 :            :    class, or a local variable) do not have linkage at all, and this
    2878                 :            :    macro should not be used in those cases.
    2879                 :            : 
    2880                 :            :    Implementation note: A FUNCTION_DECL without DECL_LANG_SPECIFIC was
    2881                 :            :    created by language-independent code, and has C linkage.  Most
    2882                 :            :    VAR_DECLs have C++ linkage, and do not have DECL_LANG_SPECIFIC, but
    2883                 :            :    we do create DECL_LANG_SPECIFIC for variables with non-C++ linkage.  */
    2884                 :            : #define DECL_LANGUAGE(NODE)                             \
    2885                 :            :   (DECL_LANG_SPECIFIC (NODE)                            \
    2886                 :            :    ? DECL_LANG_SPECIFIC (NODE)->u.base.language              \
    2887                 :            :    : (TREE_CODE (NODE) == FUNCTION_DECL                 \
    2888                 :            :       ? lang_c : lang_cplusplus))
    2889                 :            : 
    2890                 :            : /* Set the language linkage for NODE to LANGUAGE.  */
    2891                 :            : #define SET_DECL_LANGUAGE(NODE, LANGUAGE) \
    2892                 :            :   (DECL_LANG_SPECIFIC (NODE)->u.base.language = (LANGUAGE))
    2893                 :            : 
    2894                 :            : /* For FUNCTION_DECLs and TEMPLATE_DECLs: nonzero means that this function
    2895                 :            :    is a constructor.  */
    2896                 :            : #define DECL_CONSTRUCTOR_P(NODE) \
    2897                 :            :   DECL_CXX_CONSTRUCTOR_P (STRIP_TEMPLATE (NODE))
    2898                 :            : 
    2899                 :            : /* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a complete
    2900                 :            :    object.  */
    2901                 :            : #define DECL_COMPLETE_CONSTRUCTOR_P(NODE)               \
    2902                 :            :   (DECL_NAME (NODE) == complete_ctor_identifier)
    2903                 :            : 
    2904                 :            : /* Nonzero if NODE (a FUNCTION_DECL) is a constructor for a base
    2905                 :            :    object.  */
    2906                 :            : #define DECL_BASE_CONSTRUCTOR_P(NODE)           \
    2907                 :            :   (DECL_NAME (NODE) == base_ctor_identifier)
    2908                 :            : 
    2909                 :            : /* Nonzero if NODE (a FUNCTION_DECL) is a constructor, but not either the
    2910                 :            :    specialized in-charge constructor or the specialized not-in-charge
    2911                 :            :    constructor.  */
    2912                 :            : #define DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P(NODE)                \
    2913                 :            :   (DECL_NAME (NODE) == ctor_identifier)
    2914                 :            : 
    2915                 :            : /* Nonzero if NODE (a FUNCTION_DECL) is a copy constructor.  */
    2916                 :            : #define DECL_COPY_CONSTRUCTOR_P(NODE) \
    2917                 :            :   (DECL_CONSTRUCTOR_P (NODE) && copy_fn_p (NODE) > 0)
    2918                 :            : 
    2919                 :            : /* Nonzero if NODE (a FUNCTION_DECL) is a move constructor.  */
    2920                 :            : #define DECL_MOVE_CONSTRUCTOR_P(NODE) \
    2921                 :            :   (DECL_CONSTRUCTOR_P (NODE) && move_fn_p (NODE))
    2922                 :            : 
    2923                 :            : /* Nonzero if NODE (a FUNCTION_DECL or TEMPLATE_DECL)
    2924                 :            :    is a destructor.  */
    2925                 :            : #define DECL_DESTRUCTOR_P(NODE)                         \
    2926                 :            :   DECL_CXX_DESTRUCTOR_P (STRIP_TEMPLATE (NODE))
    2927                 :            : 
    2928                 :            : /* Nonzero if NODE (a FUNCTION_DECL) is a destructor, but not the
    2929                 :            :    specialized in-charge constructor, in-charge deleting constructor,
    2930                 :            :    or the base destructor.  */
    2931                 :            : #define DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P(NODE)                 \
    2932                 :            :   (DECL_NAME (NODE) == dtor_identifier)
    2933                 :            : 
    2934                 :            : /* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete
    2935                 :            :    object.  */
    2936                 :            : #define DECL_COMPLETE_DESTRUCTOR_P(NODE)                \
    2937                 :            :   (DECL_NAME (NODE) == complete_dtor_identifier)
    2938                 :            : 
    2939                 :            : /* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a base
    2940                 :            :    object.  */
    2941                 :            : #define DECL_BASE_DESTRUCTOR_P(NODE)            \
    2942                 :            :   (DECL_NAME (NODE) == base_dtor_identifier)
    2943                 :            : 
    2944                 :            : /* Nonzero if NODE (a FUNCTION_DECL) is a destructor for a complete
    2945                 :            :    object that deletes the object after it has been destroyed.  */
    2946                 :            : #define DECL_DELETING_DESTRUCTOR_P(NODE)                \
    2947                 :            :   (DECL_NAME (NODE) == deleting_dtor_identifier)
    2948                 :            : 
    2949                 :            : /* Nonzero if either DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P or
    2950                 :            :    DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P is true of NODE.  */
    2951                 :            : #define DECL_MAYBE_IN_CHARGE_CDTOR_P(NODE)              \
    2952                 :            :   (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (NODE)            \
    2953                 :            :    || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (NODE))
    2954                 :            : 
    2955                 :            : /* Nonzero if NODE (a _DECL) is a cloned constructor or
    2956                 :            :    destructor.  */
    2957                 :            : #define DECL_CLONED_FUNCTION_P(NODE)            \
    2958                 :            :   (DECL_NAME (NODE)                             \
    2959                 :            :    && IDENTIFIER_CDTOR_P (DECL_NAME (NODE))     \
    2960                 :            :    && !DECL_MAYBE_IN_CHARGE_CDTOR_P (NODE))
    2961                 :            : 
    2962                 :            : /* If DECL_CLONED_FUNCTION_P holds, this is the function that was
    2963                 :            :    cloned.  */
    2964                 :            : #define DECL_CLONED_FUNCTION(NODE)              \
    2965                 :            :   (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (NODE))->u.fn.u5.cloned_function)
    2966                 :            : 
    2967                 :            : /* Perform an action for each clone of FN, if FN is a function with
    2968                 :            :    clones.  This macro should be used like:
    2969                 :            : 
    2970                 :            :       FOR_EACH_CLONE (clone, fn)
    2971                 :            :         { ... }
    2972                 :            : 
    2973                 :            :   */
    2974                 :            : #define FOR_EACH_CLONE(CLONE, FN)                       \
    2975                 :            :   if (!(TREE_CODE (FN) == FUNCTION_DECL                 \
    2976                 :            :         && DECL_MAYBE_IN_CHARGE_CDTOR_P (FN)))          \
    2977                 :            :     ;                                                   \
    2978                 :            :   else                                                  \
    2979                 :            :     for (CLONE = DECL_CHAIN (FN);                       \
    2980                 :            :          CLONE && DECL_CLONED_FUNCTION_P (CLONE);       \
    2981                 :            :          CLONE = DECL_CHAIN (CLONE))
    2982                 :            : 
    2983                 :            : /* Nonzero if NODE has DECL_DISCRIMINATOR and not DECL_ACCESS.  */
    2984                 :            : #define DECL_DISCRIMINATOR_P(NODE)                              \
    2985                 :            :   (((TREE_CODE (NODE) == VAR_DECL && TREE_STATIC (NODE))        \
    2986                 :            :     || DECL_IMPLICIT_TYPEDEF_P (NODE))                          \
    2987                 :            :    && DECL_FUNCTION_SCOPE_P (NODE))
    2988                 :            : 
    2989                 :            : /* Discriminator for name mangling.  */
    2990                 :            : #define DECL_DISCRIMINATOR(NODE) (LANG_DECL_MIN_CHECK (NODE)->access)
    2991                 :            : 
    2992                 :            : /* The index of a user-declared parameter in its function, starting at 1.
    2993                 :            :    All artificial parameters will have index 0.  */
    2994                 :            : #define DECL_PARM_INDEX(NODE) \
    2995                 :            :   (LANG_DECL_PARM_CHECK (NODE)->index)
    2996                 :            : 
    2997                 :            : /* The level of a user-declared parameter in its function, starting at 1.
    2998                 :            :    A parameter of the function will have level 1; a parameter of the first
    2999                 :            :    nested function declarator (i.e. t in void f (void (*p)(T t))) will have
    3000                 :            :    level 2.  */
    3001                 :            : #define DECL_PARM_LEVEL(NODE) \
    3002                 :            :   (LANG_DECL_PARM_CHECK (NODE)->level)
    3003                 :            : 
    3004                 :            : /* Nonzero if the VTT parm has been added to NODE.  */
    3005                 :            : #define DECL_HAS_VTT_PARM_P(NODE) \
    3006                 :            :   (LANG_DECL_FN_CHECK (NODE)->has_vtt_parm_p)
    3007                 :            : 
    3008                 :            : /* Nonzero if NODE is a FUNCTION_DECL for which a VTT parameter is
    3009                 :            :    required.  */
    3010                 :            : #define DECL_NEEDS_VTT_PARM_P(NODE)                     \
    3011                 :            :   (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (NODE))         \
    3012                 :            :    && (DECL_BASE_CONSTRUCTOR_P (NODE)                   \
    3013                 :            :        || DECL_BASE_DESTRUCTOR_P (NODE)))
    3014                 :            : 
    3015                 :            : /* Nonzero if NODE is a user-defined conversion operator.  */
    3016                 :            : #define DECL_CONV_FN_P(NODE) IDENTIFIER_CONV_OP_P (DECL_NAME (NODE))
    3017                 :            : 
    3018                 :            : /* The type to which conversion operator FN converts to.   */
    3019                 :            : #define DECL_CONV_FN_TYPE(FN) \
    3020                 :            :   TREE_TYPE ((gcc_checking_assert (DECL_CONV_FN_P (FN)), DECL_NAME (FN)))
    3021                 :            : 
    3022                 :            : /* Nonzero if NODE, a static data member, was declared in its class as an
    3023                 :            :    array of unknown bound.  */
    3024                 :            : #define VAR_HAD_UNKNOWN_BOUND(NODE)                     \
    3025                 :            :   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))           \
    3026                 :            :    ? DECL_LANG_SPECIFIC (NODE)->u.base.unknown_bound_p       \
    3027                 :            :    : false)
    3028                 :            : #define SET_VAR_HAD_UNKNOWN_BOUND(NODE) \
    3029                 :            :   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.unknown_bound_p = true)
    3030                 :            : 
    3031                 :            : /* True iff decl NODE is for an overloaded operator.  */
    3032                 :            : #define DECL_OVERLOADED_OPERATOR_P(NODE)                \
    3033                 :            :   IDENTIFIER_ANY_OP_P (DECL_NAME (NODE))
    3034                 :            : 
    3035                 :            : /* Nonzero if NODE is an assignment operator (including += and such).  */
    3036                 :            : #define DECL_ASSIGNMENT_OPERATOR_P(NODE)                 \
    3037                 :            :   IDENTIFIER_ASSIGN_OP_P (DECL_NAME (NODE))
    3038                 :            : 
    3039                 :            : /* NODE is a function_decl for an overloaded operator.  Return its
    3040                 :            :    compressed (raw) operator code.  Note that this is not a TREE_CODE.  */
    3041                 :            : #define DECL_OVERLOADED_OPERATOR_CODE_RAW(NODE)         \
    3042                 :            :   (LANG_DECL_FN_CHECK (NODE)->ovl_op_code)
    3043                 :            : 
    3044                 :            : /* DECL is an overloaded operator.  Test whether it is for TREE_CODE
    3045                 :            :    (a literal constant).  */
    3046                 :            : #define DECL_OVERLOADED_OPERATOR_IS(DECL, CODE)                 \
    3047                 :            :   (DECL_OVERLOADED_OPERATOR_CODE_RAW (DECL) == OVL_OP_##CODE)
    3048                 :            : 
    3049                 :            : /* For FUNCTION_DECLs: nonzero means that this function is a
    3050                 :            :    constructor or a destructor with an extra in-charge parameter to
    3051                 :            :    control whether or not virtual bases are constructed.  */
    3052                 :            : #define DECL_HAS_IN_CHARGE_PARM_P(NODE) \
    3053                 :            :   (LANG_DECL_FN_CHECK (NODE)->has_in_charge_parm_p)
    3054                 :            : 
    3055                 :            : /* Nonzero if DECL is a declaration of __builtin_constant_p.  */
    3056                 :            : #define DECL_IS_BUILTIN_CONSTANT_P(NODE)                \
    3057                 :            :  (TREE_CODE (NODE) == FUNCTION_DECL                     \
    3058                 :            :   && DECL_BUILT_IN_CLASS (NODE) == BUILT_IN_NORMAL      \
    3059                 :            :   && DECL_FUNCTION_CODE (NODE) == BUILT_IN_CONSTANT_P)
    3060                 :            : 
    3061                 :            : /* Nonzero for _DECL means that this decl appears in (or will appear
    3062                 :            :    in) as a member in a RECORD_TYPE or UNION_TYPE node.  It is also for
    3063                 :            :    detecting circularity in case members are multiply defined.  In the
    3064                 :            :    case of a VAR_DECL, it means that no definition has been seen, even
    3065                 :            :    if an initializer has been.  */
    3066                 :            : #define DECL_IN_AGGR_P(NODE) (DECL_LANG_FLAG_3 (NODE))
    3067                 :            : 
    3068                 :            : /* Nonzero for a VAR_DECL means that the variable's initialization (if
    3069                 :            :    any) has been processed.  (In general, DECL_INITIALIZED_P is
    3070                 :            :    !DECL_EXTERNAL, but static data members may be initialized even if
    3071                 :            :    not defined.)  */
    3072                 :            : #define DECL_INITIALIZED_P(NODE) \
    3073                 :            :    (TREE_LANG_FLAG_1 (VAR_DECL_CHECK (NODE)))
    3074                 :            : 
    3075                 :            : /* Nonzero for a VAR_DECL iff an explicit initializer was provided
    3076                 :            :    or a non-trivial constructor is called.  */
    3077                 :            : #define DECL_NONTRIVIALLY_INITIALIZED_P(NODE)   \
    3078                 :            :    (TREE_LANG_FLAG_6 (VAR_DECL_CHECK (NODE)))
    3079                 :            : 
    3080                 :            : /* Nonzero for a VAR_DECL that was initialized with a
    3081                 :            :    constant-expression.  */
    3082                 :            : #define DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P(NODE) \
    3083                 :            :   (TREE_LANG_FLAG_2 (VAR_DECL_CHECK (NODE)))
    3084                 :            : 
    3085                 :            : /* Nonzero if the DECL was initialized in the class definition itself,
    3086                 :            :    rather than outside the class.  This is used for both static member
    3087                 :            :    VAR_DECLS, and FUNCTION_DECLS that are defined in the class.  */
    3088                 :            : #define DECL_INITIALIZED_IN_CLASS_P(DECL) \
    3089                 :            :   (DECL_LANG_SPECIFIC (VAR_OR_FUNCTION_DECL_CHECK (DECL)) \
    3090                 :            :    ->u.base.initialized_in_class)
    3091                 :            : 
    3092                 :            : /* Nonzero if the DECL is used in the sense of 3.2 [basic.def.odr].
    3093                 :            :    Only available for decls with DECL_LANG_SPECIFIC.  */
    3094                 :            : #define DECL_ODR_USED(DECL) \
    3095                 :            :   (DECL_LANG_SPECIFIC (VAR_OR_FUNCTION_DECL_CHECK (DECL)) \
    3096                 :            :    ->u.base.odr_used)
    3097                 :            : 
    3098                 :            : /* Nonzero for DECL means that this decl is just a friend declaration,
    3099                 :            :    and should not be added to the list of members for this class.  */
    3100                 :            : #define DECL_FRIEND_P(NODE) \
    3101                 :            :   (DECL_LANG_SPECIFIC (TYPE_FUNCTION_OR_TEMPLATE_DECL_CHECK (NODE)) \
    3102                 :            :    ->u.base.friend_or_tls)
    3103                 :            : 
    3104                 :            : /* Nonzero if the thread-local variable was declared with __thread as
    3105                 :            :    opposed to thread_local.  */
    3106                 :            : #define DECL_GNU_TLS_P(NODE)                            \
    3107                 :            :   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))           \
    3108                 :            :    && DECL_LANG_SPECIFIC (NODE)->u.base.friend_or_tls)
    3109                 :            : #define SET_DECL_GNU_TLS_P(NODE)                                \
    3110                 :            :   (retrofit_lang_decl (VAR_DECL_CHECK (NODE)),                  \
    3111                 :            :    DECL_LANG_SPECIFIC (NODE)->u.base.friend_or_tls = true)
    3112                 :            : 
    3113                 :            : /* A TREE_LIST of the types which have befriended this FUNCTION_DECL.  */
    3114                 :            : #define DECL_BEFRIENDING_CLASSES(NODE) \
    3115                 :            :   (LANG_DECL_FN_CHECK (NODE)->befriending_classes)
    3116                 :            : 
    3117                 :            : /* Nonzero for FUNCTION_DECL means that this decl is a static
    3118                 :            :    member function.  */
    3119                 :            : #define DECL_STATIC_FUNCTION_P(NODE) \
    3120                 :            :   (LANG_DECL_FN_CHECK (NODE)->static_function)
    3121                 :            : 
    3122                 :            : /* Nonzero for FUNCTION_DECL means that this decl is a non-static
    3123                 :            :    member function.  */
    3124                 :            : #define DECL_NONSTATIC_MEMBER_FUNCTION_P(NODE) \
    3125                 :            :   (TREE_CODE (TREE_TYPE (NODE)) == METHOD_TYPE)
    3126                 :            : 
    3127                 :            : /* Nonzero for FUNCTION_DECL means that this decl is a member function
    3128                 :            :    (static or non-static).  */
    3129                 :            : #define DECL_FUNCTION_MEMBER_P(NODE) \
    3130                 :            :   (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE) || DECL_STATIC_FUNCTION_P (NODE))
    3131                 :            : 
    3132                 :            : /* Nonzero for FUNCTION_DECL means that this member function
    3133                 :            :    has `this' as const X *const.  */
    3134                 :            : #define DECL_CONST_MEMFUNC_P(NODE)                                       \
    3135                 :            :   (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE)                               \
    3136                 :            :    && CP_TYPE_CONST_P (TREE_TYPE (TREE_VALUE                             \
    3137                 :            :                                   (TYPE_ARG_TYPES (TREE_TYPE (NODE))))))
    3138                 :            : 
    3139                 :            : /* Nonzero for FUNCTION_DECL means that this member function
    3140                 :            :    has `this' as volatile X *const.  */
    3141                 :            : #define DECL_VOLATILE_MEMFUNC_P(NODE)                                    \
    3142                 :            :   (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE)                               \
    3143                 :            :    && CP_TYPE_VOLATILE_P (TREE_TYPE (TREE_VALUE                          \
    3144                 :            :                                   (TYPE_ARG_TYPES (TREE_TYPE (NODE))))))
    3145                 :            : 
    3146                 :            : /* Nonzero for a DECL means that this member is a non-static member.  */
    3147                 :            : #define DECL_NONSTATIC_MEMBER_P(NODE)           \
    3148                 :            :   (DECL_NONSTATIC_MEMBER_FUNCTION_P (NODE)      \
    3149                 :            :    || TREE_CODE (NODE) == FIELD_DECL)
    3150                 :            : 
    3151                 :            : /* Nonzero for a FIELD_DECL means that this member object type
    3152                 :            :    is mutable.  */
    3153                 :            : #define DECL_MUTABLE_P(NODE) (DECL_LANG_FLAG_0 (FIELD_DECL_CHECK (NODE)))
    3154                 :            : 
    3155                 :            : /* Nonzero for _DECL means that this constructor or conversion function is
    3156                 :            :    non-converting.  */
    3157                 :            : #define DECL_NONCONVERTING_P(NODE) \
    3158                 :            :   (LANG_DECL_FN_CHECK (NODE)->nonconverting)
    3159                 :            : 
    3160                 :            : /* Nonzero for FUNCTION_DECL means that this member function is a pure
    3161                 :            :    virtual function.  */
    3162                 :            : #define DECL_PURE_VIRTUAL_P(NODE) \
    3163                 :            :   (LANG_DECL_FN_CHECK (NODE)->pure_virtual)
    3164                 :            : 
    3165                 :            : /* Nonzero for FUNCTION_DECL means that this member function (either
    3166                 :            :    a constructor or a conversion function) has an explicit specifier
    3167                 :            :    with a value-dependent expression.  */
    3168                 :            : #define DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P(NODE) \
    3169                 :            :   (LANG_DECL_FN_CHECK (NODE)->has_dependent_explicit_spec_p)
    3170                 :            : 
    3171                 :            : /* Nonzero for a defaulted FUNCTION_DECL for which we haven't decided yet if
    3172                 :            :    it's deleted.  */
    3173                 :            : #define DECL_MAYBE_DELETED(NODE) \
    3174                 :            :   (LANG_DECL_FN_CHECK (NODE)->maybe_deleted)
    3175                 :            : 
    3176                 :            : /* True (in a FUNCTION_DECL) if NODE is a virtual function that is an
    3177                 :            :    invalid overrider for a function from a base class.  Once we have
    3178                 :            :    complained about an invalid overrider we avoid complaining about it
    3179                 :            :    again.  */
    3180                 :            : #define DECL_INVALID_OVERRIDER_P(NODE) \
    3181                 :            :   (DECL_LANG_FLAG_4 (NODE))
    3182                 :            : 
    3183                 :            : /* True (in a FUNCTION_DECL) if NODE is a function declared with
    3184                 :            :    an override virt-specifier */
    3185                 :            : #define DECL_OVERRIDE_P(NODE) (TREE_LANG_FLAG_0 (NODE))
    3186                 :            : 
    3187                 :            : /* The thunks associated with NODE, a FUNCTION_DECL.  */
    3188                 :            : #define DECL_THUNKS(NODE) \
    3189                 :            :   (DECL_VIRTUAL_P (NODE) ? LANG_DECL_FN_CHECK (NODE)->context : NULL_TREE)
    3190                 :            : 
    3191                 :            : /* Set DECL_THUNKS.  */
    3192                 :            : #define SET_DECL_THUNKS(NODE,THUNKS) \
    3193                 :            :   (LANG_DECL_FN_CHECK (NODE)->context = (THUNKS))
    3194                 :            : 
    3195                 :            : /* If NODE, a FUNCTION_DECL, is a C++11 inheriting constructor, then this
    3196                 :            :    is the constructor it inherits from.  */
    3197                 :            : #define DECL_INHERITED_CTOR(NODE) \
    3198                 :            :   (DECL_DECLARES_FUNCTION_P (NODE) && DECL_CONSTRUCTOR_P (NODE) \
    3199                 :            :    ? LANG_DECL_FN_CHECK (NODE)->context : NULL_TREE)
    3200                 :            : 
    3201                 :            : /* And this is the base that constructor comes from.  */
    3202                 :            : #define DECL_INHERITED_CTOR_BASE(NODE)                  \
    3203                 :            :   (DECL_INHERITED_CTOR (NODE)                           \
    3204                 :            :    ? DECL_CONTEXT (flag_new_inheriting_ctors            \
    3205                 :            :                    ? strip_inheriting_ctors (NODE)      \
    3206                 :            :                    : DECL_INHERITED_CTOR (NODE))        \
    3207                 :            :    : NULL_TREE)
    3208                 :            : 
    3209                 :            : /* Set the inherited base.  */
    3210                 :            : #define SET_DECL_INHERITED_CTOR(NODE,INH) \
    3211                 :            :   (LANG_DECL_FN_CHECK (NODE)->context = (INH))
    3212                 :            : 
    3213                 :            : /* Nonzero if NODE is a thunk, rather than an ordinary function.  */
    3214                 :            : #define DECL_THUNK_P(NODE)                      \
    3215                 :            :   (TREE_CODE (NODE) == FUNCTION_DECL            \
    3216                 :            :    && DECL_LANG_SPECIFIC (NODE)                 \
    3217                 :            :    && LANG_DECL_FN_CHECK (NODE)->thunk_p)
    3218                 :            : 
    3219                 :            : /* Set DECL_THUNK_P for node.  */
    3220                 :            : #define SET_DECL_THUNK_P(NODE, THIS_ADJUSTING)                  \
    3221                 :            :   (LANG_DECL_FN_CHECK (NODE)->thunk_p = 1,                   \
    3222                 :            :    LANG_DECL_FN_CHECK (NODE)->this_thunk_p = (THIS_ADJUSTING))
    3223                 :            : 
    3224                 :            : /* Nonzero if NODE is a this pointer adjusting thunk.  */
    3225                 :            : #define DECL_THIS_THUNK_P(NODE)                 \
    3226                 :            :   (DECL_THUNK_P (NODE) && LANG_DECL_FN_CHECK (NODE)->this_thunk_p)
    3227                 :            : 
    3228                 :            : /* Nonzero if NODE is a result pointer adjusting thunk.  */
    3229                 :            : #define DECL_RESULT_THUNK_P(NODE)                       \
    3230                 :            :   (DECL_THUNK_P (NODE) && !LANG_DECL_FN_CHECK (NODE)->this_thunk_p)
    3231                 :            : 
    3232                 :            : /* Nonzero if NODE is a FUNCTION_DECL, but not a thunk.  */
    3233                 :            : #define DECL_NON_THUNK_FUNCTION_P(NODE)                         \
    3234                 :            :   (TREE_CODE (NODE) == FUNCTION_DECL && !DECL_THUNK_P (NODE))
    3235                 :            : 
    3236                 :            : /* Nonzero if NODE is `extern "C"'.  */
    3237                 :            : #define DECL_EXTERN_C_P(NODE) \
    3238                 :            :   (DECL_LANGUAGE (NODE) == lang_c)
    3239                 :            : 
    3240                 :            : /* Nonzero if NODE is an `extern "C"' function.  */
    3241                 :            : #define DECL_EXTERN_C_FUNCTION_P(NODE) \
    3242                 :            :   (DECL_NON_THUNK_FUNCTION_P (NODE) && DECL_EXTERN_C_P (NODE))
    3243                 :            : 
    3244                 :            : /* True if DECL is declared 'constexpr'.  */
    3245                 :            : #define DECL_DECLARED_CONSTEXPR_P(DECL) \
    3246                 :            :   DECL_LANG_FLAG_8 (VAR_OR_FUNCTION_DECL_CHECK (STRIP_TEMPLATE (DECL)))
    3247                 :            : 
    3248                 :            : /* True if FNDECL is an immediate function.  */
    3249                 :            : #define DECL_IMMEDIATE_FUNCTION_P(NODE) \
    3250                 :            :   (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (STRIP_TEMPLATE (NODE)))     \
    3251                 :            :    ? LANG_DECL_FN_CHECK (NODE)->immediate_fn_p                               \
    3252                 :            :    : false)
    3253                 :            : #define SET_DECL_IMMEDIATE_FUNCTION_P(NODE) \
    3254                 :            :   (retrofit_lang_decl (FUNCTION_DECL_CHECK (NODE)),                     \
    3255                 :            :    LANG_DECL_FN_CHECK (NODE)->immediate_fn_p = true)
    3256                 :            : 
    3257                 :            : // True if NODE was declared as 'concept'.  The flag implies that the
    3258                 :            : // declaration is constexpr, that the declaration cannot be specialized or
    3259                 :            : // refined, and that the result type must be convertible to bool.
    3260                 :            : #define DECL_DECLARED_CONCEPT_P(NODE) \
    3261                 :            :   (DECL_LANG_SPECIFIC (NODE)->u.base.concept_p)
    3262                 :            : 
    3263                 :            : /* Nonzero if this DECL is the __PRETTY_FUNCTION__ variable in a
    3264                 :            :    template function.  */
    3265                 :            : #define DECL_PRETTY_FUNCTION_P(NODE) \
    3266                 :            :   (DECL_NAME (NODE) \
    3267                 :            :    && id_equal (DECL_NAME (NODE), "__PRETTY_FUNCTION__"))
    3268                 :            : 
    3269                 :            : /* For a DECL, true if it is __func__ or similar.  */
    3270                 :            : #define DECL_FNAME_P(NODE)                                      \
    3271                 :            :   (VAR_P (NODE) && DECL_NAME (NODE) && DECL_ARTIFICIAL (NODE)   \
    3272                 :            :    && DECL_HAS_VALUE_EXPR_P (NODE)                              \
    3273                 :            :    && (id_equal (DECL_NAME (NODE), "__PRETTY_FUNCTION__")     \
    3274                 :            :        || id_equal (DECL_NAME (NODE), "__FUNCTION__")         \
    3275                 :            :        || id_equal (DECL_NAME (NODE), "__func__")))
    3276                 :            : 
    3277                 :            : /* Nonzero if the variable was declared to be thread-local.
    3278                 :            :    We need a special C++ version of this test because the middle-end
    3279                 :            :    DECL_THREAD_LOCAL_P uses the symtab, so we can't use it for
    3280                 :            :    templates.  */
    3281                 :            : #define CP_DECL_THREAD_LOCAL_P(NODE) \
    3282                 :            :   (TREE_LANG_FLAG_0 (VAR_DECL_CHECK (NODE)))
    3283                 :            : 
    3284                 :            : /* The _TYPE context in which this _DECL appears.  This field holds the
    3285                 :            :    class where a virtual function instance is actually defined.  */
    3286                 :            : #define DECL_CLASS_CONTEXT(NODE) \
    3287                 :            :   (DECL_CLASS_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : NULL_TREE)
    3288                 :            : 
    3289                 :            : /* For a non-member friend function, the class (if any) in which this
    3290                 :            :    friend was defined.  For example, given:
    3291                 :            : 
    3292                 :            :      struct S { friend void f () { ... } };
    3293                 :            : 
    3294                 :            :    the DECL_FRIEND_CONTEXT for `f' will be `S'.  */
    3295                 :            : #define DECL_FRIEND_CONTEXT(NODE)                               \
    3296                 :            :   ((DECL_DECLARES_FUNCTION_P (NODE)                             \
    3297                 :            :     && DECL_FRIEND_P (NODE) && !DECL_FUNCTION_MEMBER_P (NODE))  \
    3298                 :            :    ? LANG_DECL_FN_CHECK (NODE)->context                              \
    3299                 :            :    : NULL_TREE)
    3300                 :            : 
    3301                 :            : /* Set the DECL_FRIEND_CONTEXT for NODE to CONTEXT.  */
    3302                 :            : #define SET_DECL_FRIEND_CONTEXT(NODE, CONTEXT) \
    3303                 :            :   (LANG_DECL_FN_CHECK (NODE)->context = (CONTEXT))
    3304                 :            : 
    3305                 :            : #define CP_DECL_CONTEXT(NODE) \
    3306                 :            :   (!DECL_FILE_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : global_namespace)
    3307                 :            : #define CP_TYPE_CONTEXT(NODE) \
    3308                 :            :   (!TYPE_FILE_SCOPE_P (NODE) ? TYPE_CONTEXT (NODE) : global_namespace)
    3309                 :            : #define FROB_CONTEXT(NODE) \
    3310                 :            :   ((NODE) == global_namespace ? DECL_CONTEXT (NODE) : (NODE))
    3311                 :            : 
    3312                 :            : /* 1 iff NODE has namespace scope, including the global namespace.  */
    3313                 :            : #define DECL_NAMESPACE_SCOPE_P(NODE)                            \
    3314                 :            :   (!DECL_TEMPLATE_PARM_P (NODE)                                 \
    3315                 :            :    && TREE_CODE (CP_DECL_CONTEXT (NODE)) == NAMESPACE_DECL)
    3316                 :            : 
    3317                 :            : #define TYPE_NAMESPACE_SCOPE_P(NODE) \
    3318                 :            :   (TREE_CODE (CP_TYPE_CONTEXT (NODE)) == NAMESPACE_DECL)
    3319                 :            : 
    3320                 :            : #define NAMESPACE_SCOPE_P(NODE) \
    3321                 :            :   ((DECL_P (NODE) && DECL_NAMESPACE_SCOPE_P (NODE)) \
    3322                 :            :    || (TYPE_P (NODE) && TYPE_NAMESPACE_SCOPE_P (NODE)))
    3323                 :            : 
    3324                 :            : /* 1 iff NODE is a class member.  */
    3325                 :            : #define DECL_CLASS_SCOPE_P(NODE) \
    3326                 :            :   (DECL_CONTEXT (NODE) && TYPE_P (DECL_CONTEXT (NODE)))
    3327                 :            : 
    3328                 :            : #define TYPE_CLASS_SCOPE_P(NODE) \
    3329                 :            :   (TYPE_CONTEXT (NODE) && TYPE_P (TYPE_CONTEXT (NODE)))
    3330                 :            : 
    3331                 :            : /* 1 iff NODE is function-local.  */
    3332                 :            : #define DECL_FUNCTION_SCOPE_P(NODE) \
    3333                 :            :   (DECL_CONTEXT (NODE) \
    3334                 :            :    && TREE_CODE (DECL_CONTEXT (NODE)) == FUNCTION_DECL)
    3335                 :            : 
    3336                 :            : #define TYPE_FUNCTION_SCOPE_P(NODE) \
    3337                 :            :   (TYPE_CONTEXT (NODE) && TREE_CODE (TYPE_CONTEXT (NODE)) == FUNCTION_DECL)
    3338                 :            : 
    3339                 :            : /* 1 iff VAR_DECL node NODE is a type-info decl.  This flag is set for
    3340                 :            :    both the primary typeinfo object and the associated NTBS name.  */
    3341                 :            : #define DECL_TINFO_P(NODE) TREE_LANG_FLAG_4 (VAR_DECL_CHECK (NODE))
    3342                 :            : 
    3343                 :            : /* 1 iff VAR_DECL node NODE is virtual table or VTT.  We forward to
    3344                 :            :    DECL_VIRTUAL_P from the common code, as that has the semantics we
    3345                 :            :    need.  But we want a more descriptive name.  */
    3346                 :            : #define DECL_VTABLE_OR_VTT_P(NODE) DECL_VIRTUAL_P (VAR_DECL_CHECK (NODE))
    3347                 :            : 
    3348                 :            : /* 1 iff FUNCTION_TYPE or METHOD_TYPE has a ref-qualifier (either & or &&). */
    3349                 :            : #define FUNCTION_REF_QUALIFIED(NODE) \
    3350                 :            :   TREE_LANG_FLAG_4 (FUNC_OR_METHOD_CHECK (NODE))
    3351                 :            : 
    3352                 :            : /* 1 iff FUNCTION_TYPE or METHOD_TYPE has &&-ref-qualifier.  */
    3353                 :            : #define FUNCTION_RVALUE_QUALIFIED(NODE) \
    3354                 :            :   TREE_LANG_FLAG_5 (FUNC_OR_METHOD_CHECK (NODE))
    3355                 :            : 
    3356                 :            : /* 1 iff NODE is function-local, but for types.  */
    3357                 :            : #define LOCAL_CLASS_P(NODE)                             \
    3358                 :            :   (decl_function_context (TYPE_MAIN_DECL (NODE)) != NULL_TREE)
    3359                 :            : 
    3360                 :            : /* The nesting depth of namespace, class or function.  Makes is_ancestor much
    3361                 :            :    simpler.  Only 8 bits available.  */
    3362                 :            : #define SCOPE_DEPTH(NODE) \
    3363                 :            :   (NAMESPACE_DECL_CHECK (NODE)->base.u.bits.address_space)
    3364                 :            : 
    3365                 :            : /* Whether the namepace is an inline namespace.  */
    3366                 :            : #define DECL_NAMESPACE_INLINE_P(NODE) \
    3367                 :            :   TREE_LANG_FLAG_0 (NAMESPACE_DECL_CHECK (NODE))
    3368                 :            : 
    3369                 :            : /* In a NAMESPACE_DECL, a vector of inline namespaces.  */
    3370                 :            : #define DECL_NAMESPACE_INLINEES(NODE) \
    3371                 :            :    (LANG_DECL_NS_CHECK (NODE)->inlinees)
    3372                 :            : 
    3373                 :            : /* Pointer to hash_map from IDENTIFIERS to DECLS  */
    3374                 :            : #define DECL_NAMESPACE_BINDINGS(NODE) \
    3375                 :            :    (LANG_DECL_NS_CHECK (NODE)->bindings)
    3376                 :            : 
    3377                 :            : /* In a NAMESPACE_DECL, points to the original namespace if this is
    3378                 :            :    a namespace alias.  */
    3379                 :            : #define DECL_NAMESPACE_ALIAS(NODE) \
    3380                 :            :         DECL_ABSTRACT_ORIGIN (NAMESPACE_DECL_CHECK (NODE))
    3381                 :            : #define ORIGINAL_NAMESPACE(NODE)  \
    3382                 :            :   (DECL_NAMESPACE_ALIAS (NODE) ? DECL_NAMESPACE_ALIAS (NODE) : (NODE))
    3383                 :            : 
    3384                 :            : /* Nonzero if NODE is the std namespace.  */
    3385                 :            : #define DECL_NAMESPACE_STD_P(NODE)                      \
    3386                 :            :   ((NODE) == std_node)
    3387                 :            : 
    3388                 :            : /* In a TREE_LIST in an attribute list, indicates that the attribute
    3389                 :            :    must be applied at instantiation time.  */
    3390                 :            : #define ATTR_IS_DEPENDENT(NODE) TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
    3391                 :            : 
    3392                 :            : /* In a TREE_LIST in the argument of attribute abi_tag, indicates that the tag
    3393                 :            :    was inherited from a template parameter, not explicitly indicated.  */
    3394                 :            : #define ABI_TAG_IMPLICIT(NODE) TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
    3395                 :            : 
    3396                 :            : /* Non zero if this is a using decl for a dependent scope. */
    3397                 :            : #define DECL_DEPENDENT_P(NODE) DECL_LANG_FLAG_0 (USING_DECL_CHECK (NODE))
    3398                 :            : 
    3399                 :            : /* The scope named in a using decl.  */
    3400                 :            : #define USING_DECL_SCOPE(NODE) DECL_RESULT_FLD (USING_DECL_CHECK (NODE))
    3401                 :            : 
    3402                 :            : /* The decls named by a using decl.  */
    3403                 :            : #define USING_DECL_DECLS(NODE) DECL_INITIAL (USING_DECL_CHECK (NODE))
    3404                 :            : 
    3405                 :            : /* Non zero if the using decl refers to a dependent type.  */
    3406                 :            : #define USING_DECL_TYPENAME_P(NODE) DECL_LANG_FLAG_1 (USING_DECL_CHECK (NODE))
    3407                 :            : 
    3408                 :            : /* In a FUNCTION_DECL, this is nonzero if this function was defined in
    3409                 :            :    the class definition.  We have saved away the text of the function,
    3410                 :            :    but have not yet processed it.  */
    3411                 :            : #define DECL_PENDING_INLINE_P(NODE) \
    3412                 :            :   (LANG_DECL_FN_CHECK (NODE)->pending_inline_p)
    3413                 :            : 
    3414                 :            : /* If DECL_PENDING_INLINE_P holds, this is the saved text of the
    3415                 :            :    function.  */
    3416                 :            : #define DECL_PENDING_INLINE_INFO(NODE) \
    3417                 :            :   (LANG_DECL_FN_CHECK (NODE)->u.pending_inline_info)
    3418                 :            : 
    3419                 :            : /* Nonzero for TYPE_DECL means that it was written 'using name = type'.  */
    3420                 :            : #define TYPE_DECL_ALIAS_P(NODE) \
    3421                 :            :   DECL_LANG_FLAG_6 (TYPE_DECL_CHECK (NODE))
    3422                 :            : 
    3423                 :            : /* Nonzero for TEMPLATE_DECL means that it is a 'complex' alias template.  */
    3424                 :            : #define TEMPLATE_DECL_COMPLEX_ALIAS_P(NODE) \
    3425                 :            :   DECL_LANG_FLAG_2 (TEMPLATE_DECL_CHECK (NODE))
    3426                 :            : 
    3427                 :            : /* Nonzero for a type which is an alias for another type; i.e, a type
    3428                 :            :    which declaration was written 'using name-of-type =
    3429                 :            :    another-type'.  */
    3430                 :            : #define TYPE_ALIAS_P(NODE)                      \
    3431                 :            :   (TYPE_P (NODE)                                \
    3432                 :            :    && TYPE_NAME (NODE)                          \
    3433                 :            :    && TREE_CODE (TYPE_NAME (NODE)) == TYPE_DECL \
    3434                 :            :    && TYPE_DECL_ALIAS_P (TYPE_NAME (NODE)))
    3435                 :            : 
    3436                 :            : /* If non-NULL for a VAR_DECL, FUNCTION_DECL, TYPE_DECL, TEMPLATE_DECL,
    3437                 :            :    or CONCEPT_DECL, the entity is either a template specialization (if
    3438                 :            :    DECL_USE_TEMPLATE is nonzero) or the abstract instance of the
    3439                 :            :    template itself.
    3440                 :            : 
    3441                 :            :    In either case, DECL_TEMPLATE_INFO is a TEMPLATE_INFO, whose
    3442                 :            :    TI_TEMPLATE is the TEMPLATE_DECL of which this entity is a
    3443                 :            :    specialization or abstract instance.  The TI_ARGS is the
    3444                 :            :    template arguments used to specialize the template.
    3445                 :            : 
    3446                 :            :    Consider:
    3447                 :            : 
    3448                 :            :       template <typename T> struct S { friend void f(T) {} };
    3449                 :            : 
    3450                 :            :    In this case, S<int>::f is, from the point of view of the compiler,
    3451                 :            :    an instantiation of a template -- but, from the point of view of
    3452                 :            :    the language, each instantiation of S results in a wholly unrelated
    3453                 :            :    global function f.  In this case, DECL_TEMPLATE_INFO for S<int>::f
    3454                 :            :    will be non-NULL, but DECL_USE_TEMPLATE will be zero.  */
    3455                 :            : #define DECL_TEMPLATE_INFO(NODE) \
    3456                 :            :   (DECL_LANG_SPECIFIC (TEMPLATE_INFO_DECL_CHECK (NODE)) \
    3457                 :            :    ->u.min.template_info)
    3458                 :            : 
    3459                 :            : /* For a lambda capture proxy, its captured variable.  */
    3460                 :            : #define DECL_CAPTURED_VARIABLE(NODE) \
    3461                 :            :   (LANG_DECL_MIN_CHECK (NODE)->access)
    3462                 :            : 
    3463                 :            : /* For a VAR_DECL, indicates that the variable is actually a
    3464                 :            :    non-static data member of anonymous union that has been promoted to
    3465                 :            :    variable status.  */
    3466                 :            : #define DECL_ANON_UNION_VAR_P(NODE) \
    3467                 :            :   (DECL_LANG_FLAG_4 (VAR_DECL_CHECK (NODE)))
    3468                 :            : 
    3469                 :            : /* Template information for a RECORD_TYPE or UNION_TYPE.  */
    3470                 :            : #define CLASSTYPE_TEMPLATE_INFO(NODE) \
    3471                 :            :   (TYPE_LANG_SLOT_1 (RECORD_OR_UNION_CHECK (NODE)))
    3472                 :            : 
    3473                 :            : /* Template information for a template template parameter.  */
    3474                 :            : #define TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO(NODE) \
    3475                 :            :   (TYPE_LANG_SLOT_1 (BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK (NODE)))
    3476                 :            : 
    3477                 :            : /* Template information for an ENUMERAL_, RECORD_, UNION_TYPE, or
    3478                 :            :    BOUND_TEMPLATE_TEMPLATE_PARM type.  This ignores any alias
    3479                 :            :    templateness of NODE.  It'd be nice if this could unconditionally
    3480                 :            :    access the slot, rather than return NULL if given a
    3481                 :            :    non-templatable type.  */
    3482                 :            : #define TYPE_TEMPLATE_INFO(NODE)                                        \
    3483                 :            :   (TREE_CODE (NODE) == ENUMERAL_TYPE                                    \
    3484                 :            :    || TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM                  \
    3485                 :            :    || RECORD_OR_UNION_TYPE_P (NODE)                                     \
    3486                 :            :    ? TYPE_LANG_SLOT_1 (NODE) : NULL_TREE)
    3487                 :            : 
    3488                 :            : /* Template information (if any) for an alias type.  */
    3489                 :            : #define TYPE_ALIAS_TEMPLATE_INFO(NODE)                                  \
    3490                 :            :   (DECL_LANG_SPECIFIC (TYPE_NAME (NODE))                                \
    3491                 :            :    ? DECL_TEMPLATE_INFO (TYPE_NAME (NODE))                              \
    3492                 :            :    : NULL_TREE)
    3493                 :            : 
    3494                 :            : /* If NODE is a type alias, this accessor returns the template info
    3495                 :            :    for the alias template (if any).  Otherwise behave as
    3496                 :            :    TYPE_TEMPLATE_INFO.  */
    3497                 :            : #define TYPE_TEMPLATE_INFO_MAYBE_ALIAS(NODE)                            \
    3498                 :            :   (typedef_variant_p (NODE)                                             \
    3499                 :            :    ? TYPE_ALIAS_TEMPLATE_INFO (NODE)                                    \
    3500                 :            :    : TYPE_TEMPLATE_INFO (NODE))
    3501                 :            : 
    3502                 :            : /* Set the template information for an ENUMERAL_, RECORD_, or
    3503                 :            :    UNION_TYPE to VAL.  */
    3504                 :            : #define SET_TYPE_TEMPLATE_INFO(NODE, VAL)                               \
    3505                 :            :   (TREE_CODE (NODE) == ENUMERAL_TYPE                                    \
    3506                 :            :    || (CLASS_TYPE_P (NODE) && !TYPE_ALIAS_P (NODE))                     \
    3507                 :            :    ? (TYPE_LANG_SLOT_1 (NODE) = (VAL))                          \
    3508                 :            :    : (DECL_TEMPLATE_INFO (TYPE_NAME (NODE)) = (VAL)))
    3509                 :            : 
    3510                 :            : #define TI_TEMPLATE(NODE) \
    3511                 :            :   ((struct tree_template_info*)TEMPLATE_INFO_CHECK (NODE))->tmpl
    3512                 :            : #define TI_ARGS(NODE) \
    3513                 :            :   ((struct tree_template_info*)TEMPLATE_INFO_CHECK (NODE))->args
    3514                 :            : #define TI_PENDING_TEMPLATE_FLAG(NODE) \
    3515                 :            :   TREE_LANG_FLAG_1 (TEMPLATE_INFO_CHECK (NODE))
    3516                 :            : /* For a given TREE_VEC containing a template argument list,
    3517                 :            :    this property contains the number of arguments that are not
    3518                 :            :    defaulted.  */
    3519                 :            : #define NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \
    3520                 :            :   TREE_CHAIN (TREE_VEC_CHECK (NODE))
    3521                 :            : 
    3522                 :            : /* Below are the setter and getter of the NON_DEFAULT_TEMPLATE_ARGS_COUNT
    3523                 :            :    property.  */
    3524                 :            : #define SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE, INT_VALUE) \
    3525                 :            :   NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) = build_int_cst (NULL_TREE, INT_VALUE)
    3526                 :            : #if CHECKING_P
    3527                 :            : #define GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \
    3528                 :            :     int_cst_value (NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE))
    3529                 :            : #else
    3530                 :            : #define GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \
    3531                 :            :   NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE) \
    3532                 :            :   ? int_cst_value (NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE)) \
    3533                 :            :   : TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (NODE))
    3534                 :            : #endif
    3535                 :            : /* The list of typedefs - used in the template - that need
    3536                 :            :    access checking at template instantiation time.
    3537                 :            : 
    3538                 :            :    FIXME this should be associated with the TEMPLATE_DECL, not the
    3539                 :            :    TEMPLATE_INFO.  */
    3540                 :            : #define TI_TYPEDEFS_NEEDING_ACCESS_CHECKING(NODE) \
    3541                 :            :   ((struct tree_template_info*)TEMPLATE_INFO_CHECK \
    3542                 :            :      (NODE))->typedefs_needing_access_checking
    3543                 :            : 
    3544                 :            : /* We use TREE_VECs to hold template arguments.  If there is only one
    3545                 :            :    level of template arguments, then the TREE_VEC contains the
    3546                 :            :    arguments directly.  If there is more than one level of template
    3547                 :            :    arguments, then each entry in the TREE_VEC is itself a TREE_VEC,
    3548                 :            :    containing the template arguments for a single level.  The first
    3549                 :            :    entry in the outer TREE_VEC is the outermost level of template
    3550                 :            :    parameters; the last is the innermost.
    3551                 :            : 
    3552                 :            :    It is incorrect to ever form a template argument vector containing
    3553                 :            :    only one level of arguments, but which is a TREE_VEC containing as
    3554                 :            :    its only entry the TREE_VEC for that level.
    3555                 :            : 
    3556                 :            :    For each TREE_VEC containing the template arguments for a single
    3557                 :            :    level, it's possible to get or set the number of non defaulted
    3558                 :            :    template arguments by using the accessor macros
    3559                 :            :    GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT or
    3560                 :            :    SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT.  */
    3561                 :            : 
    3562                 :            : /* Nonzero if the template arguments is actually a vector of vectors,
    3563                 :            :    rather than just a vector.  */
    3564                 :            : #define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE)                 \
    3565                 :            :   (NODE && TREE_VEC_LENGTH (NODE) && TREE_VEC_ELT (NODE, 0)  \
    3566                 :            :    && TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC)
    3567                 :            : 
    3568                 :            : /* The depth of a template argument vector.  When called directly by
    3569                 :            :    the parser, we use a TREE_LIST rather than a TREE_VEC to represent
    3570                 :            :    template arguments.  In fact, we may even see NULL_TREE if there
    3571                 :            :    are no template arguments.  In both of those cases, there is only
    3572                 :            :    one level of template arguments.  */
    3573                 :            : #define TMPL_ARGS_DEPTH(NODE)                                   \
    3574                 :            :   (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) : 1)
    3575                 :            : 
    3576                 :            : /* The LEVELth level of the template ARGS.  The outermost level of
    3577                 :            :    args is level 1, not level 0.  */
    3578                 :            : #define TMPL_ARGS_LEVEL(ARGS, LEVEL)            \
    3579                 :            :   (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS)        \
    3580                 :            :    ? TREE_VEC_ELT (ARGS, (LEVEL) - 1) : (ARGS))
    3581                 :            : 
    3582                 :            : /* Set the LEVELth level of the template ARGS to VAL.  This macro does
    3583                 :            :    not work with single-level argument vectors.  */
    3584                 :            : #define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL)   \
    3585                 :            :   (TREE_VEC_ELT (ARGS, (LEVEL) - 1) = (VAL))
    3586                 :            : 
    3587                 :            : /* Accesses the IDXth parameter in the LEVELth level of the ARGS.  */
    3588                 :            : #define TMPL_ARG(ARGS, LEVEL, IDX)                              \
    3589                 :            :   (TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX))
    3590                 :            : 
    3591                 :            : /* Given a single level of template arguments in NODE, return the
    3592                 :            :    number of arguments.  */
    3593                 :            : #define NUM_TMPL_ARGS(NODE)                             \
    3594                 :            :   (TREE_VEC_LENGTH (NODE))
    3595                 :            : 
    3596                 :            : /* Returns the innermost level of template arguments in ARGS.  */
    3597                 :            : #define INNERMOST_TEMPLATE_ARGS(NODE) \
    3598                 :            :   (get_innermost_template_args ((NODE), 1))
    3599                 :            : 
    3600                 :            : /* The number of levels of template parameters given by NODE.  */
    3601                 :            : #define TMPL_PARMS_DEPTH(NODE) \
    3602                 :            :   ((HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_PURPOSE (NODE)))
    3603                 :            : 
    3604                 :            : /* The TEMPLATE_DECL instantiated or specialized by NODE.  This
    3605                 :            :    TEMPLATE_DECL will be the immediate parent, not the most general
    3606                 :            :    template.  For example, in:
    3607                 :            : 
    3608                 :            :       template <class T> struct S { template <class U> void f(U); }
    3609                 :            : 
    3610                 :            :    the FUNCTION_DECL for S<int>::f<double> will have, as its
    3611                 :            :    DECL_TI_TEMPLATE, `template <class U> S<int>::f<U>'.
    3612                 :            : 
    3613                 :            :    As a special case, for a member friend template of a template
    3614                 :            :    class, this value will not be a TEMPLATE_DECL, but rather an
    3615                 :            :    IDENTIFIER_NODE or OVERLOAD indicating the name of the template and
    3616                 :            :    any explicit template arguments provided.  For example, in:
    3617                 :            : 
    3618                 :            :      template <class T> struct S { friend void f<int>(int, double); }
    3619                 :            : 
    3620                 :            :    the DECL_TI_TEMPLATE will be an IDENTIFIER_NODE for `f' and the
    3621                 :            :    DECL_TI_ARGS will be {int}.
    3622                 :            : 
    3623                 :            :    For a FIELD_DECL with a non-static data member initializer, this value
    3624                 :            :    is the FIELD_DECL it was instantiated from.  */
    3625                 :            : #define DECL_TI_TEMPLATE(NODE)      TI_TEMPLATE (DECL_TEMPLATE_INFO (NODE))
    3626                 :            : 
    3627                 :            : /* The template arguments used to obtain this decl from the most
    3628                 :            :    general form of DECL_TI_TEMPLATE.  For the example given for
    3629                 :            :    DECL_TI_TEMPLATE, the DECL_TI_ARGS will be {int, double}.  These
    3630                 :            :    are always the full set of arguments required to instantiate this
    3631                 :            :    declaration from the most general template specialized here.  */
    3632                 :            : #define DECL_TI_ARGS(NODE)          TI_ARGS (DECL_TEMPLATE_INFO (NODE))
    3633                 :            : 
    3634                 :            : /* The TEMPLATE_DECL associated with NODE, a class type.  Even if NODE
    3635                 :            :    will be generated from a partial specialization, the TEMPLATE_DECL
    3636                 :            :    referred to here will be the original template.  For example,
    3637                 :            :    given:
    3638                 :            : 
    3639                 :            :       template <typename T> struct S {};
    3640                 :            :       template <typename T> struct S<T*> {};
    3641                 :            :       
    3642                 :            :    the CLASSTPYE_TI_TEMPLATE for S<int*> will be S, not the S<T*>.
    3643                 :            : 
    3644                 :            :    For a member class template, CLASSTYPE_TI_TEMPLATE always refers to the
    3645                 :            :    partial instantiation rather than the primary template.  CLASSTYPE_TI_ARGS
    3646                 :            :    are for the primary template if the partial instantiation isn't
    3647                 :            :    specialized, or for the explicit specialization if it is, e.g.
    3648                 :            : 
    3649                 :            :       template <class T> class C { template <class U> class D; }
    3650                 :            :       template <> template <class U> class C<int>::D;  */
    3651                 :            : #define CLASSTYPE_TI_TEMPLATE(NODE) TI_TEMPLATE (CLASSTYPE_TEMPLATE_INFO (NODE))
    3652                 :            : #define CLASSTYPE_TI_ARGS(NODE)     TI_ARGS (CLASSTYPE_TEMPLATE_INFO (NODE))
    3653                 :            : 
    3654                 :            : /* For a template instantiation TYPE, returns the TYPE corresponding
    3655                 :            :    to the primary template.  Otherwise returns TYPE itself.  */
    3656                 :            : #define CLASSTYPE_PRIMARY_TEMPLATE_TYPE(TYPE)                           \
    3657                 :            :   ((CLASSTYPE_USE_TEMPLATE ((TYPE))                                     \
    3658                 :            :     && !CLASSTYPE_TEMPLATE_SPECIALIZATION ((TYPE)))                     \
    3659                 :            :    ? TREE_TYPE (DECL_TEMPLATE_RESULT (DECL_PRIMARY_TEMPLATE             \
    3660                 :            :                                       (CLASSTYPE_TI_TEMPLATE ((TYPE))))) \
    3661                 :            :    : (TYPE))
    3662                 :            : 
    3663                 :            : /* Like CLASS_TI_TEMPLATE, but also works for ENUMERAL_TYPEs.  */
    3664                 :            : #define TYPE_TI_TEMPLATE(NODE)                  \
    3665                 :            :   (TI_TEMPLATE (TYPE_TEMPLATE_INFO (NODE)))
    3666                 :            : 
    3667                 :            : /* Like DECL_TI_ARGS, but for an ENUMERAL_, RECORD_, or UNION_TYPE.  */
    3668                 :            : #define TYPE_TI_ARGS(NODE)                      \
    3669                 :            :   (TI_ARGS (TYPE_TEMPLATE_INFO (NODE)))
    3670                 :            : 
    3671                 :            : #define INNERMOST_TEMPLATE_PARMS(NODE)  TREE_VALUE (NODE)
    3672                 :            : 
    3673                 :            : /* Nonzero if NODE (a TEMPLATE_DECL) is a member template, in the
    3674                 :            :    sense of [temp.mem].  */
    3675                 :            : #define DECL_MEMBER_TEMPLATE_P(NODE) \
    3676                 :            :   (DECL_LANG_FLAG_1 (TEMPLATE_DECL_CHECK (NODE)))
    3677                 :            : 
    3678                 :            : /* Nonzero if the NODE corresponds to the template parameters for a
    3679                 :            :    member template, whose inline definition is being processed after
    3680                 :            :    the class definition is complete.  */
    3681                 :            : #define TEMPLATE_PARMS_FOR_INLINE(NODE) TREE_LANG_FLAG_1 (NODE)
    3682                 :            : 
    3683                 :            : /* Determine if a declaration (PARM_DECL or FIELD_DECL) is a pack.  */
    3684                 :            : #define DECL_PACK_P(NODE) \
    3685                 :            :   (DECL_P (NODE) && PACK_EXPANSION_P (TREE_TYPE (NODE)))
    3686                 :            : 
    3687                 :            : /* Determines if NODE is an expansion of one or more parameter packs,
    3688                 :            :    e.g., a TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION.  */
    3689                 :            : #define PACK_EXPANSION_P(NODE)                 \
    3690                 :            :   (TREE_CODE (NODE) == TYPE_PACK_EXPANSION     \
    3691                 :            :    || TREE_CODE (NODE) == EXPR_PACK_EXPANSION)
    3692                 :            : 
    3693                 :            : /* Extracts the type or expression pattern from a TYPE_PACK_EXPANSION or
    3694                 :            :    EXPR_PACK_EXPANSION.  */
    3695                 :            : #define PACK_EXPANSION_PATTERN(NODE)                            \
    3696                 :            :   (TREE_CODE (NODE) == TYPE_PACK_EXPANSION ? TREE_TYPE (NODE)    \
    3697                 :            :    : TREE_OPERAND (NODE, 0))
    3698                 :            : 
    3699                 :            : /* Sets the type or expression pattern for a TYPE_PACK_EXPANSION or
    3700                 :            :    EXPR_PACK_EXPANSION.  */
    3701                 :            : #define SET_PACK_EXPANSION_PATTERN(NODE,VALUE)  \
    3702                 :            :   if (TREE_CODE (NODE) == TYPE_PACK_EXPANSION)  \
    3703                 :            :     TREE_TYPE (NODE) = VALUE;                   \
    3704                 :            :   else                                          \
    3705                 :            :     TREE_OPERAND (NODE, 0) = VALUE
    3706                 :            : 
    3707                 :            : /* The list of parameter packs used in the PACK_EXPANSION_* node. The
    3708                 :            :    TREE_VALUE of each TREE_LIST contains the parameter packs.  */
    3709                 :            : #define PACK_EXPANSION_PARAMETER_PACKS(NODE)            \
    3710                 :            :   *(TREE_CODE (NODE) == EXPR_PACK_EXPANSION             \
    3711                 :            :     ? &TREE_OPERAND (NODE, 1)                               \
    3712                 :            :     : &TYPE_MIN_VALUE_RAW (TYPE_PACK_EXPANSION_CHECK (NODE)))
    3713                 :            : 
    3714                 :            : /* Any additional template args to be applied when substituting into
    3715                 :            :    the pattern, set by tsubst_pack_expansion for partial instantiations.
    3716                 :            :    If this is a TREE_LIST, the TREE_VALUE of the first element is the
    3717                 :            :    usual template argument TREE_VEC, and the TREE_PURPOSE of later elements
    3718                 :            :    are enclosing functions that provided function parameter packs we'll need
    3719                 :            :    to map appropriately.  */
    3720                 :            : #define PACK_EXPANSION_EXTRA_ARGS(NODE)         \
    3721                 :            :   *(TREE_CODE (NODE) == TYPE_PACK_EXPANSION     \
    3722                 :            :     ? &TYPE_MAX_VALUE_RAW (NODE)                    \
    3723                 :            :     : &TREE_OPERAND ((NODE), 2))
    3724                 :            : 
    3725                 :            : /* True iff this pack expansion is within a function context.  */
    3726                 :            : #define PACK_EXPANSION_LOCAL_P(NODE) TREE_LANG_FLAG_0 (NODE)
    3727                 :            : 
    3728                 :            : /* True iff this pack expansion is for sizeof....  */
    3729                 :            : #define PACK_EXPANSION_SIZEOF_P(NODE) TREE_LANG_FLAG_1 (NODE)
    3730                 :            : 
    3731                 :            : /* True iff the wildcard can match a template parameter pack.  */
    3732                 :            : #define WILDCARD_PACK_P(NODE) TREE_LANG_FLAG_0 (NODE)
    3733                 :            : 
    3734                 :            : /* Determine if this is an argument pack.  */
    3735                 :            : #define ARGUMENT_PACK_P(NODE)                          \
    3736                 :            :   (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK              \
    3737                 :            :    || TREE_CODE (NODE) == NONTYPE_ARGUMENT_PACK)
    3738                 :            : 
    3739                 :            : /* The arguments stored in an argument pack. Arguments are stored in a
    3740                 :            :    TREE_VEC, which may have length zero.  */
    3741                 :            : #define ARGUMENT_PACK_ARGS(NODE)                               \
    3742                 :            :   (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK? TREE_TYPE (NODE)    \
    3743                 :            :    : TREE_OPERAND (NODE, 0))
    3744                 :            : 
    3745                 :            : /* Set the arguments stored in an argument pack. VALUE must be a
    3746                 :            :    TREE_VEC.  */
    3747                 :            : #define SET_ARGUMENT_PACK_ARGS(NODE,VALUE)     \
    3748                 :            :   if (TREE_CODE (NODE) == TYPE_ARGUMENT_PACK)  \
    3749                 :            :     TREE_TYPE (NODE) = VALUE;                           \
    3750                 :            :   else                                                  \
    3751                 :            :     TREE_OPERAND (NODE, 0) = VALUE
    3752                 :            : 
    3753                 :            : /* Whether the argument pack is "incomplete", meaning that more
    3754                 :            :    arguments can still be deduced. Incomplete argument packs are only
    3755                 :            :    used when the user has provided an explicit template argument list
    3756                 :            :    for a variadic function template. Some of the explicit template
    3757                 :            :    arguments will be placed into the beginning of the argument pack,
    3758                 :            :    but additional arguments might still be deduced.  */
    3759                 :            : #define ARGUMENT_PACK_INCOMPLETE_P(NODE)        \
    3760                 :            :   TREE_ADDRESSABLE (ARGUMENT_PACK_ARGS (NODE))
    3761                 :            : 
    3762                 :            : /* When ARGUMENT_PACK_INCOMPLETE_P, stores the explicit template
    3763                 :            :    arguments used to fill this pack.  */
    3764                 :            : #define ARGUMENT_PACK_EXPLICIT_ARGS(NODE)       \
    3765                 :            :   TREE_TYPE (ARGUMENT_PACK_ARGS (NODE))
    3766                 :            : 
    3767                 :            : /* In an ARGUMENT_PACK_SELECT, the argument pack from which an
    3768                 :            :    argument will be selected.  */
    3769                 :            : #define ARGUMENT_PACK_SELECT_FROM_PACK(NODE)                            \
    3770                 :            :   (((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->argument_pack)
    3771                 :            : 
    3772                 :            : /* In an ARGUMENT_PACK_SELECT, the index of the argument we want to
    3773                 :            :    select.  */
    3774                 :            : #define ARGUMENT_PACK_SELECT_INDEX(NODE)                                \
    3775                 :            :   (((struct tree_argument_pack_select *)ARGUMENT_PACK_SELECT_CHECK (NODE))->index)
    3776                 :            : 
    3777                 :            : #define FOLD_EXPR_CHECK(NODE)                                           \
    3778                 :            :   TREE_CHECK4 (NODE, UNARY_LEFT_FOLD_EXPR, UNARY_RIGHT_FOLD_EXPR,       \
    3779                 :            :                BINARY_LEFT_FOLD_EXPR, BINARY_RIGHT_FOLD_EXPR)
    3780                 :            : 
    3781                 :            : #define BINARY_FOLD_EXPR_CHECK(NODE) \
    3782                 :            :   TREE_CHECK2 (NODE, BINARY_LEFT_FOLD_EXPR, BINARY_RIGHT_FOLD_EXPR)
    3783                 :            : 
    3784                 :            : /* True if NODE is UNARY_FOLD_EXPR or a BINARY_FOLD_EXPR */
    3785                 :            : #define FOLD_EXPR_P(NODE)                               \
    3786                 :            :   (TREE_CODE (NODE) == UNARY_LEFT_FOLD_EXPR             \
    3787                 :            :    || TREE_CODE (NODE) == UNARY_RIGHT_FOLD_EXPR         \
    3788                 :            :    || TREE_CODE (NODE) == BINARY_LEFT_FOLD_EXPR         \
    3789                 :            :    || TREE_CODE (NODE) == BINARY_RIGHT_FOLD_EXPR)
    3790                 :            : 
    3791                 :            : /* True when NODE is a fold over a compound assignment operator. */
    3792                 :            : #define FOLD_EXPR_MODIFY_P(NODE) \
    3793                 :            :   TREE_LANG_FLAG_0 (FOLD_EXPR_CHECK (NODE))
    3794                 :            : 
    3795                 :            : /* An INTEGER_CST containing the tree code of the folded operator. */
    3796                 :            : #define FOLD_EXPR_OP(NODE) \
    3797                 :            :   TREE_OPERAND (FOLD_EXPR_CHECK (NODE), 0)
    3798                 :            : 
    3799                 :            : /* The expression containing an unexpanded parameter pack. */
    3800                 :            : #define FOLD_EXPR_PACK(NODE) \
    3801                 :            :   TREE_OPERAND (FOLD_EXPR_CHECK (NODE), 1)
    3802                 :            : 
    3803                 :            : /* In a binary fold expression, the argument with no unexpanded
    3804                 :            :    parameter packs. */
    3805                 :            : #define FOLD_EXPR_INIT(NODE) \
    3806                 :            :   TREE_OPERAND (BINARY_FOLD_EXPR_CHECK (NODE), 2)
    3807                 :            : 
    3808                 :            : /* In a FUNCTION_DECL, the saved auto-return pattern.  */
    3809                 :            : #define DECL_SAVED_AUTO_RETURN_TYPE(NODE)               \
    3810                 :            :   (LANG_DECL_FN_CHECK (FUNCTION_DECL_CHECK (NODE))      \
    3811                 :            :    ->u.saved_auto_return_type)
    3812                 :            : 
    3813                 :            : /* True if NODE is an implicit INDIRECT_REF from convert_from_reference.  */
    3814                 :            : #define REFERENCE_REF_P(NODE)                           \
    3815                 :            :   (INDIRECT_REF_P (NODE)                                \
    3816                 :            :    && TREE_TYPE (TREE_OPERAND (NODE, 0))                \
    3817                 :            :    && TYPE_REF_P (TREE_TYPE (TREE_OPERAND ((NODE), 0))))
    3818                 :            : 
    3819                 :            : #define NEW_EXPR_USE_GLOBAL(NODE) \
    3820                 :            :   TREE_LANG_FLAG_0 (NEW_EXPR_CHECK (NODE))
    3821                 :            : #define DELETE_EXPR_USE_GLOBAL(NODE) \
    3822                 :            :   TREE_LANG_FLAG_0 (DELETE_EXPR_CHECK (NODE))
    3823                 :            : #define DELETE_EXPR_USE_VEC(NODE) \
    3824                 :            :   TREE_LANG_FLAG_1 (DELETE_EXPR_CHECK (NODE))
    3825                 :            : 
    3826                 :            : #define CALL_OR_AGGR_INIT_CHECK(NODE) \
    3827                 :            :   TREE_CHECK2 ((NODE), CALL_EXPR, AGGR_INIT_EXPR)
    3828                 :            : 
    3829                 :            : /* Indicates that this is a non-dependent COMPOUND_EXPR which will
    3830                 :            :    resolve to a function call.  */
    3831                 :            : #define COMPOUND_EXPR_OVERLOADED(NODE) \
    3832                 :            :   TREE_LANG_FLAG_0 (COMPOUND_EXPR_CHECK (NODE))
    3833                 :            : 
    3834                 :            : /* In a CALL_EXPR appearing in a template, true if Koenig lookup
    3835                 :            :    should be performed at instantiation time.  */
    3836                 :            : #define KOENIG_LOOKUP_P(NODE) TREE_LANG_FLAG_0 (CALL_EXPR_CHECK (NODE))
    3837                 :            : 
    3838                 :            : /* In a CALL_EXPR, true for allocator calls from new or delete
    3839                 :            :    expressions.  */
    3840                 :            : #define CALL_FROM_NEW_OR_DELETE_P(NODE) \
    3841                 :            :   TREE_LANG_FLAG_2 (CALL_EXPR_CHECK (NODE))
    3842                 :            : 
    3843                 :            : /* True if the arguments to NODE should be evaluated in left-to-right
    3844                 :            :    order regardless of PUSH_ARGS_REVERSED.  */
    3845                 :            : #define CALL_EXPR_ORDERED_ARGS(NODE) \
    3846                 :            :   TREE_LANG_FLAG_3 (CALL_OR_AGGR_INIT_CHECK (NODE))
    3847                 :            : 
    3848                 :            : /* True if the arguments to NODE should be evaluated in right-to-left
    3849                 :            :    order regardless of PUSH_ARGS_REVERSED.  */
    3850                 :            : #define CALL_EXPR_REVERSE_ARGS(NODE) \
    3851                 :            :   TREE_LANG_FLAG_5 (CALL_OR_AGGR_INIT_CHECK (NODE))
    3852                 :            : 
    3853                 :            : /* True if CALL_EXPR was written as an operator expression, not a function
    3854                 :            :    call.  */
    3855                 :            : #define CALL_EXPR_OPERATOR_SYNTAX(NODE) \
    3856                 :            :   TREE_LANG_FLAG_6 (CALL_OR_AGGR_INIT_CHECK (NODE))
    3857                 :            : 
    3858                 :            : /* Indicates whether a string literal has been parenthesized. Such
    3859                 :            :    usages are disallowed in certain circumstances.  */
    3860                 :            : 
    3861                 :            : #define PAREN_STRING_LITERAL_P(NODE) \
    3862                 :            :   TREE_LANG_FLAG_0 (STRING_CST_CHECK (NODE))
    3863                 :            : 
    3864                 :            : /* Indicates whether a COMPONENT_REF or a SCOPE_REF has been parenthesized, or
    3865                 :            :    an INDIRECT_REF comes from parenthesizing a _DECL.  Currently only set some
    3866                 :            :    of the time in C++14 mode.  */
    3867                 :            : 
    3868                 :            : #define REF_PARENTHESIZED_P(NODE) \
    3869                 :            :   TREE_LANG_FLAG_2 (TREE_CHECK4 ((NODE), COMPONENT_REF, INDIRECT_REF, SCOPE_REF, VIEW_CONVERT_EXPR))
    3870                 :            : 
    3871                 :            : /* Nonzero if this AGGR_INIT_EXPR provides for initialization via a
    3872                 :            :    constructor call, rather than an ordinary function call.  */
    3873                 :            : #define AGGR_INIT_VIA_CTOR_P(NODE) \
    3874                 :            :   TREE_LANG_FLAG_0 (AGGR_INIT_EXPR_CHECK (NODE))
    3875                 :            : 
    3876                 :            : /* Nonzero if expanding this AGGR_INIT_EXPR should first zero-initialize
    3877                 :            :    the object.  */
    3878                 :            : #define AGGR_INIT_ZERO_FIRST(NODE) \
    3879                 :            :   TREE_LANG_FLAG_2 (AGGR_INIT_EXPR_CHECK (NODE))
    3880                 :            : 
    3881                 :            : /* Nonzero means that the call is the jump from a thunk to the
    3882                 :            :    thunked-to function.  */
    3883                 :            : #define AGGR_INIT_FROM_THUNK_P(NODE) \
    3884                 :            :   (AGGR_INIT_EXPR_CHECK (NODE)->base.protected_flag)
    3885                 :            : 
    3886                 :            : /* AGGR_INIT_EXPR accessors.  These are equivalent to the CALL_EXPR
    3887                 :            :    accessors, except for AGGR_INIT_EXPR_SLOT (which takes the place of
    3888                 :            :    CALL_EXPR_STATIC_CHAIN).  */
    3889                 :            : 
    3890                 :            : #define AGGR_INIT_EXPR_FN(NODE) TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 1)
    3891                 :            : #define AGGR_INIT_EXPR_SLOT(NODE) \
    3892                 :            :   TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 2)
    3893                 :            : #define AGGR_INIT_EXPR_ARG(NODE, I) \
    3894                 :            :   TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), (I) + 3)
    3895                 :            : #define aggr_init_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH(NODE) - 3)
    3896                 :            : 
    3897                 :            : /* AGGR_INIT_EXPR_ARGP returns a pointer to the argument vector for NODE.
    3898                 :            :    We can't use &AGGR_INIT_EXPR_ARG (NODE, 0) because that will complain if
    3899                 :            :    the argument count is zero when checking is enabled.  Instead, do
    3900                 :            :    the pointer arithmetic to advance past the 3 fixed operands in a
    3901                 :            :    AGGR_INIT_EXPR.  That produces a valid pointer to just past the end of
    3902                 :            :    the operand array, even if it's not valid to dereference it.  */
    3903                 :            : #define AGGR_INIT_EXPR_ARGP(NODE) \
    3904                 :            :   (&(TREE_OPERAND (AGGR_INIT_EXPR_CHECK (NODE), 0)) + 3)
    3905                 :            : 
    3906                 :            : /* Abstract iterators for AGGR_INIT_EXPRs.  */
    3907                 :            : 
    3908                 :            : /* Structure containing iterator state.  */
    3909                 :            : struct aggr_init_expr_arg_iterator {
    3910                 :            :   tree t;       /* the aggr_init_expr */
    3911                 :            :   int n;        /* argument count */
    3912                 :            :   int i;        /* next argument index */
    3913                 :            : };
    3914                 :            : 
    3915                 :            : /* Initialize the abstract argument list iterator object ITER with the
    3916                 :            :    arguments from AGGR_INIT_EXPR node EXP.  */
    3917                 :            : inline void
    3918                 :        100 : init_aggr_init_expr_arg_iterator (tree exp,
    3919                 :            :                                        aggr_init_expr_arg_iterator *iter)
    3920                 :            : {
    3921                 :        100 :   iter->t = exp;
    3922                 :        100 :   iter->n = aggr_init_expr_nargs (exp);
    3923                 :        100 :   iter->i = 0;
    3924                 :        100 : }
    3925                 :            : 
    3926                 :            : /* Return the next argument from abstract argument list iterator object ITER,
    3927                 :            :    and advance its state.  Return NULL_TREE if there are no more arguments.  */
    3928                 :            : inline tree
    3929                 :        254 : next_aggr_init_expr_arg (aggr_init_expr_arg_iterator *iter)
    3930                 :            : {
    3931                 :        254 :   tree result;
    3932                 :        254 :   if (iter->i >= iter->n)
    3933                 :            :     return NULL_TREE;
    3934                 :        154 :   result = AGGR_INIT_EXPR_ARG (iter->t, iter->i);
    3935                 :        154 :   iter->i++;
    3936                 :        154 :   return result;
    3937                 :            : }
    3938                 :            : 
    3939                 :            : /* Initialize the abstract argument list iterator object ITER, then advance
    3940                 :            :    past and return the first argument.  Useful in for expressions, e.g.
    3941                 :            :      for (arg = first_aggr_init_expr_arg (exp, &iter); arg;
    3942                 :            :           arg = next_aggr_init_expr_arg (&iter))   */
    3943                 :            : inline tree
    3944                 :        100 : first_aggr_init_expr_arg (tree exp, aggr_init_expr_arg_iterator *iter)
    3945                 :            : {
    3946                 :        100 :   init_aggr_init_expr_arg_iterator (exp, iter);
    3947                 :        100 :   return next_aggr_init_expr_arg (iter);
    3948                 :            : }
    3949                 :            : 
    3950                 :            : /* Test whether there are more arguments in abstract argument list iterator
    3951                 :            :    ITER, without changing its state.  */
    3952                 :            : inline bool
    3953                 :         56 : more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter)
    3954                 :            : {
    3955                 :         56 :   return (iter->i < iter->n);
    3956                 :            : }
    3957                 :            : 
    3958                 :            : /* Iterate through each argument ARG of AGGR_INIT_EXPR CALL, using variable
    3959                 :            :    ITER (of type aggr_init_expr_arg_iterator) to hold the iteration state.  */
    3960                 :            : #define FOR_EACH_AGGR_INIT_EXPR_ARG(arg, iter, call)                    \
    3961                 :            :   for ((arg) = first_aggr_init_expr_arg ((call), &(iter)); (arg);   \
    3962                 :            :        (arg) = next_aggr_init_expr_arg (&(iter)))
    3963                 :            : 
    3964                 :            : /* VEC_INIT_EXPR accessors.  */
    3965                 :            : #define VEC_INIT_EXPR_SLOT(NODE) TREE_OPERAND (VEC_INIT_EXPR_CHECK (NODE), 0)
    3966                 :            : #define VEC_INIT_EXPR_INIT(NODE) TREE_OPERAND (VEC_INIT_EXPR_CHECK (NODE), 1)
    3967                 :            : 
    3968                 :            : /* Indicates that a VEC_INIT_EXPR is a potential constant expression.
    3969                 :            :    Only set when the current function is constexpr.  */
    3970                 :            : #define VEC_INIT_EXPR_IS_CONSTEXPR(NODE) \
    3971                 :            :   TREE_LANG_FLAG_0 (VEC_INIT_EXPR_CHECK (NODE))
    3972                 :            : 
    3973                 :            : /* Indicates that a VEC_INIT_EXPR is expressing value-initialization.  */
    3974                 :            : #define VEC_INIT_EXPR_VALUE_INIT(NODE) \
    3975                 :            :   TREE_LANG_FLAG_1 (VEC_INIT_EXPR_CHECK (NODE))
    3976                 :            : 
    3977                 :            : /* The condition under which this MUST_NOT_THROW_EXPR actually blocks
    3978                 :            :    exceptions.  NULL_TREE means 'true'.  */
    3979                 :            : #define MUST_NOT_THROW_COND(NODE) \
    3980                 :            :   TREE_OPERAND (MUST_NOT_THROW_EXPR_CHECK (NODE), 1)
    3981                 :            : 
    3982                 :            : /* The TYPE_MAIN_DECL for a class template type is a TYPE_DECL, not a
    3983                 :            :    TEMPLATE_DECL.  This macro determines whether or not a given class
    3984                 :            :    type is really a template type, as opposed to an instantiation or
    3985                 :            :    specialization of one.  */
    3986                 :            : #define CLASSTYPE_IS_TEMPLATE(NODE)  \
    3987                 :            :   (CLASSTYPE_TEMPLATE_INFO (NODE)    \
    3988                 :            :    && !CLASSTYPE_USE_TEMPLATE (NODE) \
    3989                 :            :    && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE)))
    3990                 :            : 
    3991                 :            : /* The name used by the user to name the typename type.  Typically,
    3992                 :            :    this is an IDENTIFIER_NODE, and the same as the DECL_NAME on the
    3993                 :            :    corresponding TYPE_DECL.  However, this may also be a
    3994                 :            :    TEMPLATE_ID_EXPR if we had something like `typename X::Y<T>'.  */
    3995                 :            : #define TYPENAME_TYPE_FULLNAME(NODE) \
    3996                 :            :   (TYPE_VALUES_RAW (TYPENAME_TYPE_CHECK (NODE)))
    3997                 :            : 
    3998                 :            : /* True if a TYPENAME_TYPE was declared as an "enum".  */
    3999                 :            : #define TYPENAME_IS_ENUM_P(NODE) \
    4000                 :            :   (TREE_LANG_FLAG_0 (TYPENAME_TYPE_CHECK (NODE)))
    4001                 :            : 
    4002                 :            : /* True if a TYPENAME_TYPE was declared as a "class", "struct", or
    4003                 :            :    "union".  */
    4004                 :            : #define TYPENAME_IS_CLASS_P(NODE) \
    4005                 :            :   (TREE_LANG_FLAG_1 (TYPENAME_TYPE_CHECK (NODE)))
    4006                 :            : 
    4007                 :            : /* True if a TYPENAME_TYPE is in the process of being resolved.  */
    4008                 :            : #define TYPENAME_IS_RESOLVING_P(NODE) \
    4009                 :            :   (TREE_LANG_FLAG_2 (TYPENAME_TYPE_CHECK (NODE)))
    4010                 :            : 
    4011                 :            : /* [class.virtual]
    4012                 :            : 
    4013                 :            :    A class that declares or inherits a virtual function is called a
    4014                 :            :    polymorphic class.  */
    4015                 :            : #define TYPE_POLYMORPHIC_P(NODE) (TREE_LANG_FLAG_2 (NODE))
    4016                 :            : 
    4017                 :            : /* Nonzero if this class has a virtual function table pointer.  */
    4018                 :            : #define TYPE_CONTAINS_VPTR_P(NODE)              \
    4019                 :            :   (TYPE_POLYMORPHIC_P (NODE) || CLASSTYPE_VBASECLASSES (NODE))
    4020                 :            : 
    4021                 :            : /* Nonzero if NODE is a FUNCTION_DECL (for a function with global
    4022                 :            :    scope) declared in a local scope.  */
    4023                 :            : #define DECL_LOCAL_FUNCTION_P(NODE) \
    4024                 :            :   DECL_LANG_FLAG_0 (FUNCTION_DECL_CHECK (NODE))
    4025                 :            : 
    4026                 :            : /* Nonzero if NODE is the target for genericization of 'break' stmts.  */
    4027                 :            : #define LABEL_DECL_BREAK(NODE) \
    4028                 :            :   DECL_LANG_FLAG_0 (LABEL_DECL_CHECK (NODE))
    4029                 :            : 
    4030                 :            : /* Nonzero if NODE is the target for genericization of 'continue' stmts.  */
    4031                 :            : #define LABEL_DECL_CONTINUE(NODE) \
    4032                 :            :   DECL_LANG_FLAG_1 (LABEL_DECL_CHECK (NODE))
    4033                 :            : 
    4034                 :            : /* Nonzero if NODE is the target for genericization of 'return' stmts
    4035                 :            :    in constructors/destructors of targetm.cxx.cdtor_returns_this targets.  */
    4036                 :            : #define LABEL_DECL_CDTOR(NODE) \
    4037                 :            :   DECL_LANG_FLAG_2 (LABEL_DECL_CHECK (NODE))
    4038                 :            : 
    4039                 :            : /* True if NODE was declared with auto in its return type, but it has
    4040                 :            :    started compilation and so the return type might have been changed by
    4041                 :            :    return type deduction; its declared return type should be found in
    4042                 :            :    DECL_SAVED_AUTO_RETURN_TYPE (NODE).   */
    4043                 :            : #define FNDECL_USED_AUTO(NODE) \
    4044                 :            :   TREE_LANG_FLAG_2 (FUNCTION_DECL_CHECK (NODE))
    4045                 :            : 
    4046                 :            : /* Nonzero if NODE is a DECL which we know about but which has not
    4047                 :            :    been explicitly declared, such as a built-in function or a friend
    4048                 :            :    declared inside a class.  In the latter case DECL_HIDDEN_FRIEND_P
    4049                 :            :    will be set.  */
    4050                 :            : #define DECL_ANTICIPATED(NODE) \
    4051                 :            :   (DECL_LANG_SPECIFIC (TYPE_FUNCTION_OR_TEMPLATE_DECL_CHECK (NODE)) \
    4052                 :            :    ->u.base.anticipated_p)
    4053                 :            : 
    4054                 :            : /* Is DECL NODE a hidden name?  */
    4055                 :            : #define DECL_HIDDEN_P(NODE) \
    4056                 :            :   (DECL_LANG_SPECIFIC (NODE) && TYPE_FUNCTION_OR_TEMPLATE_DECL_P (NODE) \
    4057                 :            :    && DECL_ANTICIPATED (NODE))
    4058                 :            : 
    4059                 :            : /* True if this is a hidden class type.    */
    4060                 :            : #define TYPE_HIDDEN_P(NODE) \
    4061                 :            :   (DECL_LANG_SPECIFIC (TYPE_NAME (NODE)) \
    4062                 :            :    && DECL_ANTICIPATED (TYPE_NAME (NODE)))
    4063                 :            : 
    4064                 :            : /* True for artificial decls added for OpenMP privatized non-static
    4065                 :            :    data members.  */
    4066                 :            : #define DECL_OMP_PRIVATIZED_MEMBER(NODE) \
    4067                 :            :   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.anticipated_p)
    4068                 :            : 
    4069                 :            : /* Nonzero if NODE is a FUNCTION_DECL which was declared as a friend
    4070                 :            :    within a class but has not been declared in the surrounding scope.
    4071                 :            :    The function is invisible except via argument dependent lookup.  */
    4072                 :            : #define DECL_HIDDEN_FRIEND_P(NODE) \
    4073                 :            :   (LANG_DECL_FN_CHECK (DECL_COMMON_CHECK (NODE))->hidden_friend_p)
    4074                 :            : 
    4075                 :            : /* Nonzero if NODE is an artificial FUNCTION_DECL for
    4076                 :            :    #pragma omp declare reduction.  */
    4077                 :            : #define DECL_OMP_DECLARE_REDUCTION_P(NODE) \
    4078                 :            :   (LANG_DECL_FN_CHECK (DECL_COMMON_CHECK (NODE))->omp_declare_reduction_p)
    4079                 :            : 
    4080                 :            : /* Nonzero if DECL has been declared threadprivate by
    4081                 :            :    #pragma omp threadprivate.  */
    4082                 :            : #define CP_DECL_THREADPRIVATE_P(DECL) \
    4083                 :            :   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (DECL))->u.base.threadprivate_or_deleted_p)
    4084                 :            : 
    4085                 :            : /* Nonzero if NODE is a VAR_DECL which has been declared inline.  */
    4086                 :            : #define DECL_VAR_DECLARED_INLINE_P(NODE) \
    4087                 :            :   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))                   \
    4088                 :            :    ? DECL_LANG_SPECIFIC (NODE)->u.base.var_declared_inline_p \
    4089                 :            :    : false)
    4090                 :            : #define SET_DECL_VAR_DECLARED_INLINE_P(NODE) \
    4091                 :            :   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.var_declared_inline_p \
    4092                 :            :    = true)
    4093                 :            : 
    4094                 :            : /* True if NODE is a constant variable with a value-dependent initializer.  */
    4095                 :            : #define DECL_DEPENDENT_INIT_P(NODE)                             \
    4096                 :            :   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))                   \
    4097                 :            :    && DECL_LANG_SPECIFIC (NODE)->u.base.dependent_init_p)
    4098                 :            : #define SET_DECL_DEPENDENT_INIT_P(NODE, X) \
    4099                 :            :   (DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))->u.base.dependent_init_p = (X))
    4100                 :            : 
    4101                 :            : /* Nonzero if NODE is an artificial VAR_DECL for a C++17 structured binding
    4102                 :            :    declaration or one of VAR_DECLs for the user identifiers in it.  */
    4103                 :            : #define DECL_DECOMPOSITION_P(NODE) \
    4104                 :            :   (VAR_P (NODE) && DECL_LANG_SPECIFIC (NODE)                    \
    4105                 :            :    ? DECL_LANG_SPECIFIC (NODE)->u.base.selector == lds_decomp                \
    4106                 :            :    : false)
    4107                 :            : 
    4108                 :            : /* The underlying artificial VAR_DECL for structured binding.  */
    4109                 :            : #define DECL_DECOMP_BASE(NODE) \
    4110                 :            :   (LANG_DECL_DECOMP_CHECK (NODE)->base)
    4111                 :            : 
    4112                 :            : /* Nonzero if NODE is an inline VAR_DECL.  In C++17, static data members
    4113                 :            :    declared with constexpr specifier are implicitly inline variables.  */
    4114                 :            : #define DECL_INLINE_VAR_P(NODE) \
    4115                 :            :   (DECL_VAR_DECLARED_INLINE_P (NODE)                            \
    4116                 :            :    || (cxx_dialect >= cxx17                                  \
    4117                 :            :        && DECL_DECLARED_CONSTEXPR_P (NODE)                      \
    4118                 :            :        && DECL_CLASS_SCOPE_P (NODE)))
    4119                 :            : 
    4120                 :            : /* Nonzero if DECL was declared with '= delete'.  */
    4121                 :            : #define DECL_DELETED_FN(DECL) \
    4122                 :            :   (LANG_DECL_FN_CHECK (DECL)->min.base.threadprivate_or_deleted_p)
    4123                 :            : 
    4124                 :            : /* Nonzero if DECL was declared with '= default' (maybe implicitly).  */
    4125                 :            : #define DECL_DEFAULTED_FN(DECL) \
    4126                 :            :   (LANG_DECL_FN_CHECK (DECL)->defaulted_p)
    4127                 :            : 
    4128                 :            : /* Nonzero if DECL is explicitly defaulted in the class body.  */
    4129                 :            : #define DECL_DEFAULTED_IN_CLASS_P(DECL)                                 \
    4130                 :            :   (DECL_DEFAULTED_FN (DECL) && DECL_INITIALIZED_IN_CLASS_P (DECL))
    4131                 :            : /* Nonzero if DECL was defaulted outside the class body.  */
    4132                 :            : #define DECL_DEFAULTED_OUTSIDE_CLASS_P(DECL)                            \
    4133                 :            :   (DECL_DEFAULTED_FN (DECL)                                             \
    4134                 :            :    && !(DECL_ARTIFICIAL (DECL) || DECL_INITIALIZED_IN_CLASS_P (DECL)))
    4135                 :            : 
    4136                 :            : /* Record whether a typedef for type `int' was actually `signed int'.  */
    4137                 :            : #define C_TYPEDEF_EXPLICITLY_SIGNED(EXP) DECL_LANG_FLAG_1 (EXP)
    4138                 :            : 
    4139                 :            : /* Returns nonzero if DECL has external linkage, as specified by the
    4140                 :            :    language standard.  (This predicate may hold even when the
    4141                 :            :    corresponding entity is not actually given external linkage in the
    4142                 :            :    object file; see decl_linkage for details.)  */
    4143                 :            : #define DECL_EXTERNAL_LINKAGE_P(DECL) \
    4144                 :            :   (decl_linkage (DECL) == lk_external)
    4145                 :            : 
    4146                 :            : /* Keep these codes in ascending code order.  */
    4147                 :            : 
    4148                 :            : #define INTEGRAL_CODE_P(CODE)   \
    4149                 :            :   ((CODE) == ENUMERAL_TYPE      \
    4150                 :            :    || (CODE) == BOOLEAN_TYPE    \
    4151                 :            :    || (CODE) == INTEGER_TYPE)
    4152                 :            : 
    4153                 :            : /* [basic.fundamental]
    4154                 :            : 
    4155                 :            :    Types  bool, char, wchar_t, and the signed and unsigned integer types
    4156                 :            :    are collectively called integral types.
    4157                 :            : 
    4158                 :            :    Note that INTEGRAL_TYPE_P, as defined in tree.h, allows enumeration
    4159                 :            :    types as well, which is incorrect in C++.  Keep these checks in
    4160                 :            :    ascending code order.  */
    4161                 :            : #define CP_INTEGRAL_TYPE_P(TYPE)                \
    4162                 :            :   (TREE_CODE (TYPE) == BOOLEAN_TYPE             \
    4163                 :            :    || TREE_CODE (TYPE) == INTEGER_TYPE)
    4164                 :            : 
    4165                 :            : /* Returns true if TYPE is an integral or enumeration name.  Keep
    4166                 :            :    these checks in ascending code order.  */
    4167                 :            : #define INTEGRAL_OR_ENUMERATION_TYPE_P(TYPE) \
    4168                 :            :    (TREE_CODE (TYPE) == ENUMERAL_TYPE || CP_INTEGRAL_TYPE_P (TYPE))
    4169                 :            : 
    4170                 :            : /* Returns true if TYPE is an integral or unscoped enumeration type.  */
    4171                 :            : #define INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P(TYPE) \
    4172                 :            :    (UNSCOPED_ENUM_P (TYPE) || CP_INTEGRAL_TYPE_P (TYPE))
    4173                 :            : 
    4174                 :            : /* True if the class type TYPE is a literal type.  */
    4175                 :            : #define CLASSTYPE_LITERAL_P(TYPE)              \
    4176                 :            :    (LANG_TYPE_CLASS_CHECK (TYPE)->is_literal)
    4177                 :            : 
    4178                 :            : /* [basic.fundamental]
    4179                 :            : 
    4180                 :            :    Integral and floating types are collectively called arithmetic
    4181                 :            :    types.
    4182                 :            : 
    4183                 :            :    As a GNU extension, we also accept complex types.
    4184                 :            : 
    4185                 :            :    Keep these checks in ascending code order.  */
    4186                 :            : #define ARITHMETIC_TYPE_P(TYPE) \
    4187                 :            :   (CP_INTEGRAL_TYPE_P (TYPE) \
    4188                 :            :    || TREE_CODE (TYPE) == REAL_TYPE \
    4189                 :            :    || TREE_CODE (TYPE) == COMPLEX_TYPE)
    4190                 :            : 
    4191                 :            : /* True iff TYPE is cv decltype(nullptr).  */
    4192                 :            : #define NULLPTR_TYPE_P(TYPE) (TREE_CODE (TYPE) == NULLPTR_TYPE)
    4193                 :            : 
    4194                 :            : /* [basic.types]
    4195                 :            : 
    4196                 :            :    Arithmetic types, enumeration types, pointer types,
    4197                 :            :    pointer-to-member types, and std::nullptr_t are collectively called
    4198                 :            :    scalar types.
    4199                 :            : 
    4200                 :            :    Keep these checks in ascending code order.  */
    4201                 :            : #define SCALAR_TYPE_P(TYPE)                     \
    4202                 :            :   (TYPE_PTRDATAMEM_P (TYPE)                     \
    4203                 :            :    || TREE_CODE (TYPE) == ENUMERAL_TYPE         \
    4204                 :            :    || ARITHMETIC_TYPE_P (TYPE)                  \
    4205                 :            :    || TYPE_PTR_P (TYPE)                         \
    4206                 :            :    || TYPE_PTRMEMFUNC_P (TYPE)                  \
    4207                 :            :    || NULLPTR_TYPE_P (TYPE))
    4208                 :            : 
    4209                 :            : /* Determines whether this type is a C++0x scoped enumeration
    4210                 :            :    type. Scoped enumerations types are introduced via "enum class" or
    4211                 :            :    "enum struct", e.g.,
    4212                 :            : 
    4213                 :            :      enum class Color {
    4214                 :            :        Red, Green, Blue
    4215                 :            :      };
    4216                 :            : 
    4217                 :            :    Scoped enumeration types are different from normal (unscoped)
    4218                 :            :    enumeration types in several ways:
    4219                 :            : 
    4220                 :            :      - The enumerators of a scoped enumeration type are only available
    4221                 :            :        within the scope of the enumeration type and not in the
    4222                 :            :        enclosing scope. For example, the Red color can be referred to
    4223                 :            :        with "Color::Red" but not "Red".
    4224                 :            : 
    4225                 :            :      - Scoped enumerators and enumerations do not implicitly convert
    4226                 :            :        to integers or 'bool'.
    4227                 :            : 
    4228                 :            :      - The underlying type of the enum is well-defined.  */
    4229                 :            : #define SCOPED_ENUM_P(TYPE)                                             \
    4230                 :            :   (TREE_CODE (TYPE) == ENUMERAL_TYPE && ENUM_IS_SCOPED (TYPE))
    4231                 :            : 
    4232                 :            : /* Determine whether this is an unscoped enumeration type.  */
    4233                 :            : #define UNSCOPED_ENUM_P(TYPE)                                           \
    4234                 :            :   (TREE_CODE (TYPE) == ENUMERAL_TYPE && !ENUM_IS_SCOPED (TYPE))
    4235                 :            : 
    4236                 :            : /* Set the flag indicating whether an ENUMERAL_TYPE is a C++0x scoped
    4237                 :            :    enumeration type (1) or a normal (unscoped) enumeration type
    4238                 :            :    (0).  */
    4239                 :            : #define SET_SCOPED_ENUM_P(TYPE, VAL)                    \
    4240                 :            :   (ENUM_IS_SCOPED (TYPE) = (VAL))
    4241                 :            : 
    4242                 :            : #define SET_OPAQUE_ENUM_P(TYPE, VAL)                    \
    4243                 :            :   (ENUM_IS_OPAQUE (TYPE) = (VAL))
    4244                 :            : 
    4245                 :            : #define OPAQUE_ENUM_P(TYPE)                             \
    4246                 :            :   (TREE_CODE (TYPE) == ENUMERAL_TYPE && ENUM_IS_OPAQUE (TYPE))
    4247                 :            : 
    4248                 :            : /* Determines whether an ENUMERAL_TYPE has an explicit
    4249                 :            :    underlying type.  */
    4250                 :            : #define ENUM_FIXED_UNDERLYING_TYPE_P(NODE) (TYPE_LANG_FLAG_5 (NODE))
    4251                 :            : 
    4252                 :            : /* Returns the underlying type of the given enumeration type. The
    4253                 :            :    underlying type is determined in different ways, depending on the
    4254                 :            :    properties of the enum:
    4255                 :            : 
    4256                 :            :      - In C++0x, the underlying type can be explicitly specified, e.g.,
    4257                 :            : 
    4258                 :            :          enum E1 : char { ... } // underlying type is char
    4259                 :            : 
    4260                 :            :      - In a C++0x scoped enumeration, the underlying type is int
    4261                 :            :        unless otherwises specified:
    4262                 :            : 
    4263                 :            :          enum class E2 { ... } // underlying type is int
    4264                 :            : 
    4265                 :            :      - Otherwise, the underlying type is determined based on the
    4266                 :            :        values of the enumerators. In this case, the
    4267                 :            :        ENUM_UNDERLYING_TYPE will not be set until after the definition
    4268                 :            :        of the enumeration is completed by finish_enum.  */
    4269                 :            : #define ENUM_UNDERLYING_TYPE(TYPE) \
    4270                 :            :   TREE_TYPE (ENUMERAL_TYPE_CHECK (TYPE))
    4271                 :            : 
    4272                 :            : /* [dcl.init.aggr]
    4273                 :            : 
    4274                 :            :    An aggregate is an array or a class with no user-provided
    4275                 :            :    constructors, no brace-or-equal-initializers for non-static data
    4276                 :            :    members, no private or protected non-static data members, no
    4277                 :            :    base classes, and no virtual functions.
    4278                 :            : 
    4279                 :            :    As an extension, we also treat vectors as aggregates.  Keep these
    4280                 :            :    checks in ascending code order.  */
    4281                 :            : #define CP_AGGREGATE_TYPE_P(TYPE)                               \
    4282                 :            :   (gnu_vector_type_p (TYPE)                                     \
    4283                 :            :    || TREE_CODE (TYPE) == ARRAY_TYPE                            \
    4284                 :            :    || (CLASS_TYPE_P (TYPE) && COMPLETE_TYPE_P (TYPE) && !CLASSTYPE_NON_AGGREGATE (TYPE)))
    4285                 :            : 
    4286                 :            : /* Nonzero for a class type means that the class type has a
    4287                 :            :    user-declared constructor.  */
    4288                 :            : #define TYPE_HAS_USER_CONSTRUCTOR(NODE) (TYPE_LANG_FLAG_1 (NODE))
    4289                 :            : 
    4290                 :            : /* Nonzero means that the FUNCTION_TYPE or METHOD_TYPE has a
    4291                 :            :    late-specified return type.  */
    4292                 :            : #define TYPE_HAS_LATE_RETURN_TYPE(NODE) \
    4293                 :            :   (TYPE_LANG_FLAG_2 (FUNC_OR_METHOD_CHECK (NODE)))
    4294                 :            : 
    4295                 :            : /* When appearing in an INDIRECT_REF, it means that the tree structure
    4296                 :            :    underneath is actually a call to a constructor.  This is needed
    4297                 :            :    when the constructor must initialize local storage (which can
    4298                 :            :    be automatically destroyed), rather than allowing it to allocate
    4299                 :            :    space from the heap.
    4300                 :            : 
    4301                 :            :    When appearing in a SAVE_EXPR, it means that underneath
    4302                 :            :    is a call to a constructor.
    4303                 :            : 
    4304                 :            :    When appearing in a CONSTRUCTOR, the expression is a
    4305                 :            :    compound literal.
    4306                 :            : 
    4307                 :            :    When appearing in a FIELD_DECL, it means that this field
    4308                 :            :    has been duly initialized in its constructor.  */
    4309                 :            : #define TREE_HAS_CONSTRUCTOR(NODE) (TREE_LANG_FLAG_4 (NODE))
    4310                 :            : 
    4311                 :            : /* True if NODE is a brace-enclosed initializer.  */
    4312                 :            : #define BRACE_ENCLOSED_INITIALIZER_P(NODE) \
    4313                 :            :   (TREE_CODE (NODE) == CONSTRUCTOR && TREE_TYPE (NODE) == init_list_type_node)
    4314                 :            : 
    4315                 :            : /* True if NODE is a compound-literal, i.e., a brace-enclosed
    4316                 :            :    initializer cast to a particular type.  */
    4317                 :            : #define COMPOUND_LITERAL_P(NODE) \
    4318                 :            :   (TREE_CODE (NODE) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (NODE))
    4319                 :            : 
    4320                 :            : #define EMPTY_CONSTRUCTOR_P(NODE) (TREE_CODE (NODE) == CONSTRUCTOR \
    4321                 :            :                                    && vec_safe_is_empty(CONSTRUCTOR_ELTS(NODE))\
    4322                 :            :                                    && !TREE_HAS_CONSTRUCTOR (NODE))
    4323                 :            : 
    4324                 :            : /* True if NODE is a init-list used as a direct-initializer, i.e.
    4325                 :            :    B b{1,2}, not B b({1,2}) or B b = {1,2}.  */
    4326                 :            : #define CONSTRUCTOR_IS_DIRECT_INIT(NODE) (TREE_LANG_FLAG_0 (CONSTRUCTOR_CHECK (NODE)))
    4327                 :            : 
    4328                 :            : /* True if this CONSTRUCTOR is instantiation-dependent and needs to be
    4329                 :            :    substituted.  */
    4330                 :            : #define CONSTRUCTOR_IS_DEPENDENT(NODE) \
    4331                 :            :   (TREE_LANG_FLAG_1 (CONSTRUCTOR_CHECK (NODE)))
    4332                 :            : 
    4333                 :            : /* True if this CONSTRUCTOR should not be used as a variable initializer
    4334                 :            :    because it was loaded from a constexpr variable with mutable fields.  */
    4335                 :            : #define CONSTRUCTOR_MUTABLE_POISON(NODE) \
    4336                 :            :   (TREE_LANG_FLAG_2 (CONSTRUCTOR_CHECK (NODE)))
    4337                 :            : 
    4338                 :            : /* True if this typed CONSTRUCTOR represents C99 compound-literal syntax rather
    4339                 :            :    than C++11 functional cast syntax.  */
    4340                 :            : #define CONSTRUCTOR_C99_COMPOUND_LITERAL(NODE) \
    4341                 :            :   (TREE_LANG_FLAG_3 (CONSTRUCTOR_CHECK (NODE)))
    4342                 :            : 
    4343                 :            : /* True if this CONSTRUCTOR contains PLACEHOLDER_EXPRs referencing the
    4344                 :            :    CONSTRUCTOR's type not nested inside another CONSTRUCTOR marked with
    4345                 :            :    CONSTRUCTOR_PLACEHOLDER_BOUNDARY.  */
    4346                 :            : #define CONSTRUCTOR_PLACEHOLDER_BOUNDARY(NODE) \
    4347                 :            :   (TREE_LANG_FLAG_5 (CONSTRUCTOR_CHECK (NODE)))
    4348                 :            : 
    4349                 :            : #define DIRECT_LIST_INIT_P(NODE) \
    4350                 :            :    (BRACE_ENCLOSED_INITIALIZER_P (NODE) && CONSTRUCTOR_IS_DIRECT_INIT (NODE))
    4351                 :            : 
    4352                 :            : /* True if this is a designated initializer (when we allow initializer-clauses
    4353                 :            :    mixed with designated-initializer-clauses set whenever there is at least
    4354                 :            :    one designated-initializer-clause), or a C99 designator.  */
    4355                 :            : #define CONSTRUCTOR_IS_DESIGNATED_INIT(NODE) \
    4356                 :            :   (TREE_LANG_FLAG_6 (CONSTRUCTOR_CHECK (NODE)))
    4357                 :            : 
    4358                 :            : /* True if this CONSTRUCTOR comes from a parenthesized list of values, e.g.
    4359                 :            :    A(1, 2, 3).  */
    4360                 :            : #define CONSTRUCTOR_IS_PAREN_INIT(NODE) \
    4361                 :            :   (CONSTRUCTOR_CHECK(NODE)->base.private_flag)
    4362                 :            : 
    4363                 :            : /* True if NODE represents a conversion for direct-initialization in a
    4364                 :            :    template.  Set by perform_implicit_conversion_flags.  */
    4365                 :            : #define IMPLICIT_CONV_EXPR_DIRECT_INIT(NODE) \
    4366                 :            :   (TREE_LANG_FLAG_0 (IMPLICIT_CONV_EXPR_CHECK (NODE)))
    4367                 :            : 
    4368                 :            : /* True if NODE represents a dependent conversion of a non-type template
    4369                 :            :    argument.  Set by maybe_convert_nontype_argument.  */
    4370                 :            : #define IMPLICIT_CONV_EXPR_NONTYPE_ARG(NODE) \
    4371                 :            :   (TREE_LANG_FLAG_1 (IMPLICIT_CONV_EXPR_CHECK (NODE)))
    4372                 :            : 
    4373                 :            : /* True if NODE represents a conversion for braced-init-list in a
    4374                 :            :    template.  Set by perform_implicit_conversion_flags.  */
    4375                 :            : #define IMPLICIT_CONV_EXPR_BRACED_INIT(NODE) \
    4376                 :            :   (TREE_LANG_FLAG_2 (IMPLICIT_CONV_EXPR_CHECK (NODE)))
    4377                 :            : 
    4378                 :            : /* Nonzero means that an object of this type cannot be initialized using
    4379                 :            :    an initializer list.  */
    4380                 :            : #define CLASSTYPE_NON_AGGREGATE(NODE) \
    4381                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->non_aggregate)
    4382                 :            : #define TYPE_NON_AGGREGATE_CLASS(NODE) \
    4383                 :            :   (CLASS_TYPE_P (NODE) && CLASSTYPE_NON_AGGREGATE (NODE))
    4384                 :            : 
    4385                 :            : /* Nonzero if there is a non-trivial X::op=(cv X&) for this class.  */
    4386                 :            : #define TYPE_HAS_COMPLEX_COPY_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_copy_assign)
    4387                 :            : 
    4388                 :            : /* Nonzero if there is a non-trivial X::X(cv X&) for this class.  */
    4389                 :            : #define TYPE_HAS_COMPLEX_COPY_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_copy_ctor)
    4390                 :            : 
    4391                 :            : /* Nonzero if there is a non-trivial X::op=(X&&) for this class.  */
    4392                 :            : #define TYPE_HAS_COMPLEX_MOVE_ASSIGN(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_move_assign)
    4393                 :            : 
    4394                 :            : /* Nonzero if there is a non-trivial X::X(X&&) for this class.  */
    4395                 :            : #define TYPE_HAS_COMPLEX_MOVE_CTOR(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_move_ctor)
    4396                 :            : 
    4397                 :            : /* Nonzero if there is no trivial default constructor for this class.  */
    4398                 :            : #define TYPE_HAS_COMPLEX_DFLT(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_complex_dflt)
    4399                 :            : 
    4400                 :            : /* Nonzero if TYPE has a trivial destructor.  From [class.dtor]:
    4401                 :            : 
    4402                 :            :      A destructor is trivial if it is an implicitly declared
    4403                 :            :      destructor and if:
    4404                 :            : 
    4405                 :            :        - all of the direct base classes of its class have trivial
    4406                 :            :          destructors,
    4407                 :            : 
    4408                 :            :        - for all of the non-static data members of its class that are
    4409                 :            :          of class type (or array thereof), each such class has a
    4410                 :            :          trivial destructor.  */
    4411                 :            : #define TYPE_HAS_TRIVIAL_DESTRUCTOR(NODE) \
    4412                 :            :   (!TYPE_HAS_NONTRIVIAL_DESTRUCTOR (NODE))
    4413                 :            : 
    4414                 :            : /* Nonzero for _TYPE node means that this type does not have a trivial
    4415                 :            :    destructor.  Therefore, destroying an object of this type will
    4416                 :            :    involve a call to a destructor.  This can apply to objects of
    4417                 :            :    ARRAY_TYPE if the type of the elements needs a destructor.  */
    4418                 :            : #define TYPE_HAS_NONTRIVIAL_DESTRUCTOR(NODE) \
    4419                 :            :   (TYPE_LANG_FLAG_4 (NODE))
    4420                 :            : 
    4421                 :            : /* Nonzero for class type means that the default constructor is trivial.  */
    4422                 :            : #define TYPE_HAS_TRIVIAL_DFLT(NODE) \
    4423                 :            :   (TYPE_HAS_DEFAULT_CONSTRUCTOR (NODE) && ! TYPE_HAS_COMPLEX_DFLT (NODE))
    4424                 :            : 
    4425                 :            : /* Nonzero for class type means that copy initialization of this type can use
    4426                 :            :    a bitwise copy.  */
    4427                 :            : #define TYPE_HAS_TRIVIAL_COPY_CTOR(NODE) \
    4428                 :            :   (TYPE_HAS_COPY_CTOR (NODE) && ! TYPE_HAS_COMPLEX_COPY_CTOR (NODE))
    4429                 :            : 
    4430                 :            : /* Nonzero for class type means that assignment of this type can use
    4431                 :            :    a bitwise copy.  */
    4432                 :            : #define TYPE_HAS_TRIVIAL_COPY_ASSIGN(NODE) \
    4433                 :            :   (TYPE_HAS_COPY_ASSIGN (NODE) && ! TYPE_HAS_COMPLEX_COPY_ASSIGN (NODE))
    4434                 :            : 
    4435                 :            : /* Returns true if NODE is a pointer-to-data-member.  */
    4436                 :            : #define TYPE_PTRDATAMEM_P(NODE)                 \
    4437                 :            :   (TREE_CODE (NODE) == OFFSET_TYPE)
    4438                 :            : 
    4439                 :            : /* Returns true if NODE is a pointer.  */
    4440                 :            : #define TYPE_PTR_P(NODE)                        \
    4441                 :            :   (TREE_CODE (NODE) == POINTER_TYPE)
    4442                 :            : 
    4443                 :            : /* Returns true if NODE is a reference.  */
    4444                 :            : #define TYPE_REF_P(NODE)                        \
    4445                 :            :   (TREE_CODE (NODE) == REFERENCE_TYPE)
    4446                 :            : 
    4447                 :            : /* Returns true if NODE is a pointer or a reference.  */
    4448                 :            : #define INDIRECT_TYPE_P(NODE)                   \
    4449                 :            :   (TYPE_PTR_P (NODE) || TYPE_REF_P (NODE))
    4450                 :            : 
    4451                 :            : /* Returns true if NODE is an object type:
    4452                 :            : 
    4453                 :            :      [basic.types]
    4454                 :            : 
    4455                 :            :      An object type is a (possibly cv-qualified) type that is not a
    4456                 :            :      function type, not a reference type, and not a void type.
    4457                 :            : 
    4458                 :            :    Keep these checks in ascending order, for speed.  */
    4459                 :            : #define TYPE_OBJ_P(NODE)                        \
    4460                 :            :   (!TYPE_REF_P (NODE)                           \
    4461                 :            :    && !VOID_TYPE_P (NODE)                       \
    4462                 :            :    && !FUNC_OR_METHOD_TYPE_P (NODE))
    4463                 :            : 
    4464                 :            : /* Returns true if NODE is a pointer to an object.  Keep these checks
    4465                 :            :    in ascending tree code order.  */
    4466                 :            : #define TYPE_PTROB_P(NODE)                                      \
    4467                 :            :   (TYPE_PTR_P (NODE) && TYPE_OBJ_P (TREE_TYPE (NODE)))
    4468                 :            : 
    4469                 :            : /* Returns true if NODE is a reference to an object.  Keep these checks
    4470                 :            :    in ascending tree code order.  */
    4471                 :            : #define TYPE_REF_OBJ_P(NODE)                                    \
    4472                 :            :   (TYPE_REF_P (NODE) && TYPE_OBJ_P (TREE_TYPE (NODE)))
    4473                 :            : 
    4474                 :            : /* Returns true if NODE is a pointer to an object, or a pointer to
    4475                 :            :    void.  Keep these checks in ascending tree code order.  */
    4476                 :            : #define TYPE_PTROBV_P(NODE)                                     \
    4477                 :            :   (TYPE_PTR_P (NODE)                                            \
    4478                 :            :    && !FUNC_OR_METHOD_TYPE_P (TREE_TYPE (NODE)))
    4479                 :            : 
    4480                 :            : /* Returns true if NODE is a pointer to function type.  */
    4481                 :            : #define TYPE_PTRFN_P(NODE)                              \
    4482                 :            :   (TYPE_PTR_P (NODE)                                    \
    4483                 :            :    && TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE)
    4484                 :            : 
    4485                 :            : /* Returns true if NODE is a reference to function type.  */
    4486                 :            : #define TYPE_REFFN_P(NODE)                              \
    4487                 :            :   (TYPE_REF_P (NODE)                                    \
    4488                 :            :    && TREE_CODE (TREE_TYPE (NODE)) == FUNCTION_TYPE)
    4489                 :            : 
    4490                 :            : /* Returns true if NODE is a pointer to member function type.  */
    4491                 :            : #define TYPE_PTRMEMFUNC_P(NODE)         \
    4492                 :            :   (TREE_CODE (NODE) == RECORD_TYPE      \
    4493                 :            :    && TYPE_PTRMEMFUNC_FLAG (NODE))
    4494                 :            : 
    4495                 :            : #define TYPE_PTRMEMFUNC_FLAG(NODE) \
    4496                 :            :   (TYPE_LANG_FLAG_2 (RECORD_TYPE_CHECK (NODE)))
    4497                 :            : 
    4498                 :            : /* Returns true if NODE is a pointer-to-member.  */
    4499                 :            : #define TYPE_PTRMEM_P(NODE) \
    4500                 :            :   (TYPE_PTRDATAMEM_P (NODE) || TYPE_PTRMEMFUNC_P (NODE))
    4501                 :            : 
    4502                 :            : /* Returns true if NODE is a pointer or a pointer-to-member.  */
    4503                 :            : #define TYPE_PTR_OR_PTRMEM_P(NODE) \
    4504                 :            :   (TYPE_PTR_P (NODE) || TYPE_PTRMEM_P (NODE))
    4505                 :            : 
    4506                 :            : /* Indicates when overload resolution may resolve to a pointer to
    4507                 :            :    member function. [expr.unary.op]/3 */
    4508                 :            : #define PTRMEM_OK_P(NODE) \
    4509                 :            :   TREE_LANG_FLAG_0 (TREE_CHECK3 ((NODE), ADDR_EXPR, OFFSET_REF, SCOPE_REF))
    4510                 :            : 
    4511                 :            : /* Get the POINTER_TYPE to the METHOD_TYPE associated with this
    4512                 :            :    pointer to member function.  TYPE_PTRMEMFUNC_P _must_ be true,
    4513                 :            :    before using this macro.  */
    4514                 :            : #define TYPE_PTRMEMFUNC_FN_TYPE(NODE) \
    4515                 :            :   (cp_build_qualified_type (TREE_TYPE (TYPE_FIELDS (NODE)),\
    4516                 :            :                             cp_type_quals (NODE)))
    4517                 :            : 
    4518                 :            : /* As above, but can be used in places that want an lvalue at the expense
    4519                 :            :    of not necessarily having the correct cv-qualifiers.  */
    4520                 :            : #define TYPE_PTRMEMFUNC_FN_TYPE_RAW(NODE) \
    4521                 :            :   (TREE_TYPE (TYPE_FIELDS (NODE)))
    4522                 :            : 
    4523                 :            : /* Returns `A' for a type like `int (A::*)(double)' */
    4524                 :            : #define TYPE_PTRMEMFUNC_OBJECT_TYPE(NODE) \
    4525                 :            :   TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE)))
    4526                 :            : 
    4527                 :            : /* The canonical internal RECORD_TYPE from the POINTER_TYPE to
    4528                 :            :    METHOD_TYPE.  */
    4529                 :            : #define TYPE_PTRMEMFUNC_TYPE(NODE) \
    4530                 :            :   TYPE_LANG_SLOT_1 (NODE)
    4531                 :            : 
    4532                 :            : /* For a pointer-to-member type of the form `T X::*', this is `X'.
    4533                 :            :    For a type like `void (X::*)() const', this type is `X', not `const
    4534                 :            :    X'.  To get at the `const X' you have to look at the
    4535                 :            :    TYPE_PTRMEM_POINTED_TO_TYPE; there, the first parameter will have
    4536                 :            :    type `const X*'.  */
    4537                 :            : #define TYPE_PTRMEM_CLASS_TYPE(NODE)                    \
    4538                 :            :   (TYPE_PTRDATAMEM_P (NODE)                                     \
    4539                 :            :    ? TYPE_OFFSET_BASETYPE (NODE)                \
    4540                 :            :    : TYPE_PTRMEMFUNC_OBJECT_TYPE (NODE))
    4541                 :            : 
    4542                 :            : /* For a pointer-to-member type of the form `T X::*', this is `T'.  */
    4543                 :            : #define TYPE_PTRMEM_POINTED_TO_TYPE(NODE)               \
    4544                 :            :    (TYPE_PTRDATAMEM_P (NODE)                            \
    4545                 :            :     ? TREE_TYPE (NODE)                                  \
    4546                 :            :     : TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (NODE)))
    4547                 :            : 
    4548                 :            : /* For a pointer-to-member constant `X::Y' this is the RECORD_TYPE for
    4549                 :            :    `X'.  */
    4550                 :            : #define PTRMEM_CST_CLASS(NODE) \
    4551                 :            :   TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (PTRMEM_CST_CHECK (NODE)))
    4552                 :            : 
    4553                 :            : /* For a pointer-to-member constant `X::Y' this is the _DECL for
    4554                 :            :    `Y'.  */
    4555                 :            : #define PTRMEM_CST_MEMBER(NODE) \
    4556                 :            :   (((ptrmem_cst_t)PTRMEM_CST_CHECK (NODE))->member)
    4557                 :            : 
    4558                 :            : /* The expression in question for a TYPEOF_TYPE.  */
    4559                 :            : #define TYPEOF_TYPE_EXPR(NODE) (TYPE_VALUES_RAW (TYPEOF_TYPE_CHECK (NODE)))
    4560                 :            : 
    4561                 :            : /* The type in question for an UNDERLYING_TYPE.  */
    4562                 :            : #define UNDERLYING_TYPE_TYPE(NODE) \
    4563                 :            :   (TYPE_VALUES_RAW (UNDERLYING_TYPE_CHECK (NODE)))
    4564                 :            : 
    4565                 :            : /* The type in question for BASES.  */
    4566                 :            : #define BASES_TYPE(NODE) \
    4567                 :            :   (TYPE_VALUES_RAW (BASES_CHECK (NODE)))
    4568                 :            : 
    4569                 :            : #define BASES_DIRECT(NODE) \
    4570                 :            :   TREE_LANG_FLAG_0 (BASES_CHECK (NODE))
    4571                 :            : 
    4572                 :            : /* The expression in question for a DECLTYPE_TYPE.  */
    4573                 :            : #define DECLTYPE_TYPE_EXPR(NODE) (TYPE_VALUES_RAW (DECLTYPE_TYPE_CHECK (NODE)))
    4574                 :            : 
    4575                 :            : /* Whether the DECLTYPE_TYPE_EXPR of NODE was originally parsed as an
    4576                 :            :    id-expression or a member-access expression. When false, it was
    4577                 :            :    parsed as a full expression.  */
    4578                 :            : #define DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P(NODE) \
    4579                 :            :   (DECLTYPE_TYPE_CHECK (NODE))->type_common.string_flag
    4580                 :            : 
    4581                 :            : /* These flags indicate that we want different semantics from normal
    4582                 :            :    decltype: lambda capture just drops references,
    4583                 :            :    lambda proxies look through implicit dereference.  */
    4584                 :            : #define DECLTYPE_FOR_LAMBDA_CAPTURE(NODE) \
    4585                 :            :   TREE_LANG_FLAG_0 (DECLTYPE_TYPE_CHECK (NODE))
    4586                 :            : #define DECLTYPE_FOR_LAMBDA_PROXY(NODE) \
    4587                 :            :   TREE_LANG_FLAG_2 (DECLTYPE_TYPE_CHECK (NODE))
    4588                 :            : #define DECLTYPE_FOR_REF_CAPTURE(NODE) \
    4589                 :            :   TREE_LANG_FLAG_3 (DECLTYPE_TYPE_CHECK (NODE))
    4590                 :            : 
    4591                 :            : /* Nonzero for VAR_DECL and FUNCTION_DECL node means that `extern' was
    4592                 :            :    specified in its declaration.  This can also be set for an
    4593                 :            :    erroneously declared PARM_DECL.  */
    4594                 :            : #define DECL_THIS_EXTERN(NODE) \
    4595                 :            :   DECL_LANG_FLAG_2 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE))
    4596                 :            : 
    4597                 :            : /* Nonzero for VAR_DECL and FUNCTION_DECL node means that `static' was
    4598                 :            :    specified in its declaration.  This can also be set for an
    4599                 :            :    erroneously declared PARM_DECL.  */
    4600                 :            : #define DECL_THIS_STATIC(NODE) \
    4601                 :            :   DECL_LANG_FLAG_6 (VAR_FUNCTION_OR_PARM_DECL_CHECK (NODE))
    4602                 :            : 
    4603                 :            : /* Nonzero for FIELD_DECL node means that this field is a lambda capture
    4604                 :            :    field for an array of runtime bound.  */
    4605                 :            : #define DECL_VLA_CAPTURE_P(NODE) \
    4606                 :            :   DECL_LANG_FLAG_1 (FIELD_DECL_CHECK (NODE))
    4607                 :            : 
    4608                 :            : /* Nonzero for PARM_DECL node means that this is an array function
    4609                 :            :    parameter, i.e, a[] rather than *a.  */
    4610                 :            : #define DECL_ARRAY_PARAMETER_P(NODE) \
    4611                 :            :   DECL_LANG_FLAG_1 (PARM_DECL_CHECK (NODE))
    4612                 :            : 
    4613                 :            : /* Nonzero for a FIELD_DECL who's NSMDI is currently being
    4614                 :            :    instantiated.  */
    4615                 :            : #define DECL_INSTANTIATING_NSDMI_P(NODE) \
    4616                 :            :   DECL_LANG_FLAG_2 (FIELD_DECL_CHECK (NODE))
    4617                 :            : 
    4618                 :            : /* Nonzero for FIELD_DECL node means that this field is a base class
    4619                 :            :    of the parent object, as opposed to a member field.  */
    4620                 :            : #define DECL_FIELD_IS_BASE(NODE) \
    4621                 :            :   DECL_LANG_FLAG_6 (FIELD_DECL_CHECK (NODE))
    4622                 :            : 
    4623                 :            : /* Nonzero for FIELD_DECL node means that this field is a simple (no
    4624                 :            :    explicit initializer) lambda capture field, making it invisible to
    4625                 :            :    name lookup in unevaluated contexts.  */
    4626                 :            : #define DECL_NORMAL_CAPTURE_P(NODE) \
    4627                 :            :   DECL_LANG_FLAG_7 (FIELD_DECL_CHECK (NODE))
    4628                 :            : 
    4629                 :            : /* Nonzero if TYPE is an anonymous union or struct type.  We have to use a
    4630                 :            :    flag for this because "A union for which objects or pointers are
    4631                 :            :    declared is not an anonymous union" [class.union].  */
    4632                 :            : #define ANON_AGGR_TYPE_P(NODE)                          \
    4633                 :            :   (CLASS_TYPE_P (NODE) && LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr)
    4634                 :            : #define SET_ANON_AGGR_TYPE_P(NODE)                      \
    4635                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->anon_aggr = 1)
    4636                 :            : 
    4637                 :            : /* Nonzero if TYPE is an anonymous union type.  */
    4638                 :            : #define ANON_UNION_TYPE_P(NODE) \
    4639                 :            :   (TREE_CODE (NODE) == UNION_TYPE && ANON_AGGR_TYPE_P (NODE))
    4640                 :            : 
    4641                 :            : /* Define fields and accessors for nodes representing declared names.  */
    4642                 :            : 
    4643                 :            : /* True if TYPE is an unnamed structured type with a typedef for
    4644                 :            :    linkage purposes.  In that case TYPE_NAME and TYPE_STUB_DECL of the
    4645                 :            :    MAIN-VARIANT are different. */
    4646                 :            : #define TYPE_WAS_UNNAMED(NODE)                          \
    4647                 :            :   (TYPE_NAME (TYPE_MAIN_VARIANT (NODE))                 \
    4648                 :            :    != TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE)))
    4649                 :            : 
    4650                 :            : /* C++: all of these are overloaded!  These apply only to TYPE_DECLs.  */
    4651                 :            : 
    4652                 :            : /* The format of each node in the DECL_FRIENDLIST is as follows:
    4653                 :            : 
    4654                 :            :    The TREE_PURPOSE will be the name of a function, i.e., an
    4655                 :            :    IDENTIFIER_NODE.  The TREE_VALUE will be itself a TREE_LIST, whose
    4656                 :            :    TREE_VALUEs are friends with the given name.  */
    4657                 :            : #define DECL_FRIENDLIST(NODE)           (DECL_INITIAL (NODE))
    4658                 :            : #define FRIEND_NAME(LIST) (TREE_PURPOSE (LIST))
    4659                 :            : #define FRIEND_DECLS(LIST) (TREE_VALUE (LIST))
    4660                 :            : 
    4661                 :            : /* The DECL_ACCESS, if non-NULL, is a TREE_LIST.  The TREE_PURPOSE of
    4662                 :            :    each node is a type; the TREE_VALUE is the access granted for this
    4663                 :            :    DECL in that type.  The DECL_ACCESS is set by access declarations.
    4664                 :            :    For example, if a member that would normally be public in a
    4665                 :            :    derived class is made protected, then the derived class and the
    4666                 :            :    protected_access_node will appear in the DECL_ACCESS for the node.  */
    4667                 :            : #define DECL_ACCESS(NODE) (LANG_DECL_MIN_CHECK (NODE)->access)
    4668                 :            : 
    4669                 :            : /* Nonzero if the FUNCTION_DECL is a global constructor.  */
    4670                 :            : #define DECL_GLOBAL_CTOR_P(NODE) \
    4671                 :            :   (LANG_DECL_FN_CHECK (NODE)->global_ctor_p)
    4672                 :            : 
    4673                 :            : /* Nonzero if the FUNCTION_DECL is a global destructor.  */
    4674                 :            : #define DECL_GLOBAL_DTOR_P(NODE) \
    4675                 :            :   (LANG_DECL_FN_CHECK (NODE)->global_dtor_p)
    4676                 :            : 
    4677                 :            : /* Accessor macros for C++ template decl nodes.  */
    4678                 :            : 
    4679                 :            : /* The DECL_TEMPLATE_PARMS are a list.  The TREE_PURPOSE of each node
    4680                 :            :    is a INT_CST whose TREE_INT_CST_LOW indicates the level of the
    4681                 :            :    template parameters, with 1 being the outermost set of template
    4682                 :            :    parameters.  The TREE_VALUE is a vector, whose elements are the
    4683                 :            :    template parameters at each level.  Each element in the vector is a
    4684                 :            :    TREE_LIST, whose TREE_VALUE is a PARM_DECL (if the parameter is a
    4685                 :            :    non-type parameter), or a TYPE_DECL (if the parameter is a type
    4686                 :            :    parameter).  The TREE_PURPOSE is the default value, if any.  The
    4687                 :            :    TEMPLATE_PARM_INDEX for the parameter is available as the
    4688                 :            :    DECL_INITIAL (for a PARM_DECL) or as the TREE_TYPE (for a
    4689                 :            :    TYPE_DECL).
    4690                 :            : 
    4691                 :            :    FIXME: CONST_CAST_TREE is a hack that hopefully will go away after
    4692                 :            :    tree is converted to C++ class hiearchy.  */
    4693                 :            : #define DECL_TEMPLATE_PARMS(NODE)       \
    4694                 :            :    ((struct tree_template_decl *)CONST_CAST_TREE (TEMPLATE_DECL_CHECK (NODE)))->arguments
    4695                 :            : #define DECL_INNERMOST_TEMPLATE_PARMS(NODE) \
    4696                 :            :    INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (NODE))
    4697                 :            : #define DECL_NTPARMS(NODE) \
    4698                 :            :    TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (NODE))
    4699                 :            : /* For function, method, class-data templates.
    4700                 :            : 
    4701                 :            :    FIXME: CONST_CAST_TREE is a hack that hopefully will go away after
    4702                 :            :    tree is converted to C++ class hiearchy.  */
    4703                 :            : #define DECL_TEMPLATE_RESULT(NODE)      \
    4704                 :            :    ((struct tree_template_decl *)CONST_CAST_TREE(TEMPLATE_DECL_CHECK (NODE)))->result
    4705                 :            : /* For a function template at namespace scope, DECL_TEMPLATE_INSTANTIATIONS
    4706                 :            :    lists all instantiations and specializations of the function so that
    4707                 :            :    tsubst_friend_function can reassign them to another template if we find
    4708                 :            :    that the namespace-scope template is really a partial instantiation of a
    4709                 :            :    friend template.
    4710                 :            : 
    4711                 :            :    For a class template the DECL_TEMPLATE_INSTANTIATIONS lists holds
    4712                 :            :    all instantiations and specializations of the class type, including
    4713                 :            :    partial instantiations and partial specializations, so that if we
    4714                 :            :    explicitly specialize a partial instantiation we can walk the list
    4715                 :            :    in maybe_process_partial_specialization and reassign them or complain
    4716                 :            :    as appropriate.
    4717                 :            : 
    4718                 :            :    In both cases, the TREE_PURPOSE of each node contains the arguments
    4719                 :            :    used; the TREE_VALUE contains the generated variable.  The template
    4720                 :            :    arguments are always complete.  For example, given:
    4721                 :            : 
    4722                 :            :       template <class T> struct S1 {
    4723                 :            :         template <class U> struct S2 {};
    4724                 :            :         template <class U> struct S2<U*> {};
    4725                 :            :       };
    4726                 :            : 
    4727                 :            :    the record for the partial specialization will contain, as its
    4728                 :            :    argument list, { {T}, {U*} }, and will be on the
    4729                 :            :    DECL_TEMPLATE_INSTANTIATIONS list for `template <class T> template
    4730                 :            :    <class U> struct S1<T>::S2'.
    4731                 :            : 
    4732                 :            :    This list is not used for other templates.  */
    4733                 :            : #define DECL_TEMPLATE_INSTANTIATIONS(NODE) \
    4734                 :            :   DECL_SIZE_UNIT (TEMPLATE_DECL_CHECK (NODE))
    4735                 :            : 
    4736                 :            : /* For a class template, this list contains the partial
    4737                 :            :    specializations of this template.  (Full specializations are not
    4738                 :            :    recorded on this list.)  The TREE_PURPOSE holds the arguments used
    4739                 :            :    in the partial specialization (e.g., for `template <class T> struct
    4740                 :            :    S<T*, int>' this will be `T*, int'.)  The arguments will also include
    4741                 :            :    any outer template arguments.  The TREE_VALUE holds the TEMPLATE_DECL
    4742                 :            :    for the partial specialization.  The TREE_TYPE is the _TYPE node for
    4743                 :            :    the partial specialization.
    4744                 :            : 
    4745                 :            :    This list is not used for other templates.  */
    4746                 :            : #define DECL_TEMPLATE_SPECIALIZATIONS(NODE)     \
    4747                 :            :   DECL_SIZE (TEMPLATE_DECL_CHECK (NODE))
    4748                 :            : 
    4749                 :            : /* Nonzero for a DECL which is actually a template parameter.  Keep
    4750                 :            :    these checks in ascending tree code order.   */
    4751                 :            : #define DECL_TEMPLATE_PARM_P(NODE)              \
    4752                 :            :   (DECL_LANG_FLAG_0 (NODE)                      \
    4753                 :            :    && (TREE_CODE (NODE) == CONST_DECL           \
    4754                 :            :        || TREE_CODE (NODE) == PARM_DECL         \
    4755                 :            :        || TREE_CODE (NODE) == TYPE_DECL         \
    4756                 :            :        || TREE_CODE (NODE) == TEMPLATE_DECL))
    4757                 :            : 
    4758                 :            : /* Nonzero for a raw template parameter node.  */
    4759                 :            : #define TEMPLATE_PARM_P(NODE)                                   \
    4760                 :            :   (TREE_CODE (NODE) == TEMPLATE_TYPE_PARM                       \
    4761                 :            :    || TREE_CODE (NODE) == TEMPLATE_TEMPLATE_PARM                \
    4762                 :            :    || TREE_CODE (NODE) == TEMPLATE_PARM_INDEX)
    4763                 :            : 
    4764                 :            : /* Mark NODE as a template parameter.  */
    4765                 :            : #define SET_DECL_TEMPLATE_PARM_P(NODE) \
    4766                 :            :   (DECL_LANG_FLAG_0 (NODE) = 1)
    4767                 :            : 
    4768                 :            : /* Nonzero if NODE is a template template parameter.  */
    4769                 :            : #define DECL_TEMPLATE_TEMPLATE_PARM_P(NODE) \
    4770                 :            :   (TREE_CODE (NODE) == TEMPLATE_DECL && DECL_TEMPLATE_PARM_P (NODE))
    4771                 :            : 
    4772                 :            : /* Nonzero for a DECL that represents a function template.  */
    4773                 :            : #define DECL_FUNCTION_TEMPLATE_P(NODE)                          \
    4774                 :            :   (TREE_CODE (NODE) == TEMPLATE_DECL                            \
    4775                 :            :    && DECL_TEMPLATE_RESULT (NODE) != NULL_TREE                  \
    4776                 :            :    && TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == FUNCTION_DECL)
    4777                 :            : 
    4778                 :            : /* Nonzero for a DECL that represents a class template or alias
    4779                 :            :    template.  */
    4780                 :            : #define DECL_TYPE_TEMPLATE_P(NODE)                              \
    4781                 :            :   (TREE_CODE (NODE) == TEMPLATE_DECL                            \
    4782                 :            :    && DECL_TEMPLATE_RESULT (NODE) != NULL_TREE                  \
    4783                 :            :    && TREE_CODE (DECL_TEMPLATE_RESULT (NODE)) == TYPE_DECL)
    4784                 :            : 
    4785                 :            : /* Nonzero for a DECL that represents a class template.  */
    4786                 :            : #define DECL_CLASS_TEMPLATE_P(NODE)                             \
    4787                 :            :   (DECL_TYPE_TEMPLATE_P (NODE)                                  \
    4788                 :            :    && DECL_IMPLICIT_TYPEDEF_P (DECL_TEMPLATE_RESULT (NODE)))
    4789                 :            : 
    4790                 :            : /* Nonzero for a TEMPLATE_DECL that represents an alias template.  */
    4791                 :            : #define DECL_ALIAS_TEMPLATE_P(NODE)                     \
    4792                 :            :   (DECL_TYPE_TEMPLATE_P (NODE)                          \
    4793                 :            :    && !DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (NODE)))
    4794                 :            : 
    4795                 :            : /* Nonzero for a NODE which declares a type.  */
    4796                 :            : #define DECL_DECLARES_TYPE_P(NODE) \
    4797                 :            :   (TREE_CODE (NODE) == TYPE_DECL || DECL_TYPE_TEMPLATE_P (NODE))
    4798                 :            : 
    4799                 :            : /* Nonzero if NODE declares a function.  */
    4800                 :            : #define DECL_DECLARES_FUNCTION_P(NODE) \
    4801                 :            :   (TREE_CODE (NODE) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (NODE))
    4802                 :            : 
    4803                 :            : /* Nonzero if NODE is the typedef implicitly generated for a type when
    4804                 :            :    the type is declared.  In C++, `struct S {};' is roughly
    4805                 :            :    equivalent to `struct S {}; typedef struct S S;' in C.
    4806                 :            :    DECL_IMPLICIT_TYPEDEF_P will hold for the typedef indicated in this
    4807                 :            :    example.  In C++, there is a second implicit typedef for each
    4808                 :            :    class, called the injected-class-name, in the scope of `S' itself, so that
    4809                 :            :    you can say `S::S'.  DECL_SELF_REFERENCE_P will hold for that typedef.  */
    4810                 :            : #define DECL_IMPLICIT_TYPEDEF_P(NODE) \
    4811                 :            :   (TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_2 (NODE))
    4812                 :            : #define SET_DECL_IMPLICIT_TYPEDEF_P(NODE) \
    4813                 :            :   (DECL_LANG_FLAG_2 (NODE) = 1)
    4814                 :            : #define DECL_SELF_REFERENCE_P(NODE) \
    4815                 :            :   (TREE_CODE (NODE) == TYPE_DECL && DECL_LANG_FLAG_4 (NODE))
    4816                 :            : #define SET_DECL_SELF_REFERENCE_P(NODE) \
    4817                 :            :   (DECL_LANG_FLAG_4 (NODE) = 1)
    4818                 :            : 
    4819                 :            : /* A `primary' template is one that has its own template header and is not
    4820                 :            :    a partial specialization.  A member function of a class template is a
    4821                 :            :    template, but not primary.  A member template is primary.  Friend
    4822                 :            :    templates are primary, too.  */
    4823                 :            : 
    4824                 :            : /* Returns the primary template corresponding to these parameters.  */
    4825                 :            : #define DECL_PRIMARY_TEMPLATE(NODE) \
    4826                 :            :   (TREE_TYPE (DECL_INNERMOST_TEMPLATE_PARMS (NODE)))
    4827                 :            : 
    4828                 :            : /* Returns nonzero if NODE is a primary template.  */
    4829                 :            : #define PRIMARY_TEMPLATE_P(NODE) (DECL_PRIMARY_TEMPLATE (NODE) == (NODE))
    4830                 :            : 
    4831                 :            : /* Nonzero iff NODE is a specialization of a template.  The value
    4832                 :            :    indicates the type of specializations:
    4833                 :            : 
    4834                 :            :      1=implicit instantiation
    4835                 :            : 
    4836                 :            :      2=partial or explicit specialization, e.g.:
    4837                 :            : 
    4838                 :            :         template <> int min<int> (int, int),
    4839                 :            : 
    4840                 :            :      3=explicit instantiation, e.g.:
    4841                 :            : 
    4842                 :            :         template int min<int> (int, int);
    4843                 :            : 
    4844                 :            :    Note that NODE will be marked as a specialization even if the
    4845                 :            :    template it is instantiating is not a primary template.  For
    4846                 :            :    example, given:
    4847                 :            : 
    4848                 :            :      template <typename T> struct O {
    4849                 :            :        void f();
    4850                 :            :        struct I {};
    4851                 :            :      };
    4852                 :            : 
    4853                 :            :    both O<int>::f and O<int>::I will be marked as instantiations.
    4854                 :            : 
    4855                 :            :    If DECL_USE_TEMPLATE is nonzero, then DECL_TEMPLATE_INFO will also
    4856                 :            :    be non-NULL.  */
    4857                 :            : #define DECL_USE_TEMPLATE(NODE) (DECL_LANG_SPECIFIC (NODE)->u.base.use_template)
    4858                 :            : 
    4859                 :            : /* Like DECL_USE_TEMPLATE, but for class types.  */
    4860                 :            : #define CLASSTYPE_USE_TEMPLATE(NODE) \
    4861                 :            :   (LANG_TYPE_CLASS_CHECK (NODE)->use_template)
    4862                 :            : 
    4863                 :            : /* True if NODE is a specialization of a primary template.  */
    4864                 :            : #define CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P(NODE)    \
    4865                 :            :   (CLASS_TYPE_P (NODE)                                          \
    4866                 :            :    && CLASSTYPE_USE_TEMPLATE (NODE)                             \
    4867                 :            :    && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE)))
    4868                 :            : 
    4869                 :            : #define DECL_TEMPLATE_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) & 1)
    4870                 :            : #define CLASSTYPE_TEMPLATE_INSTANTIATION(NODE) \
    4871                 :            :   (CLASSTYPE_USE_TEMPLATE (NODE) & 1)
    4872                 :            : 
    4873                 :            : #define DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) == 2)
    4874                 :            : #define SET_DECL_TEMPLATE_SPECIALIZATION(NODE) (DECL_USE_TEMPLATE (NODE) = 2)
    4875                 :            : 
    4876                 :            : /* Returns true for an explicit or partial specialization of a class
    4877                 :            :    template.  */
    4878                 :            : #define CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \
    4879                 :            :   (CLASSTYPE_USE_TEMPLATE (NODE) == 2)
    4880                 :            : #define SET_CLASSTYPE_TEMPLATE_SPECIALIZATION(NODE) \
    4881                 :            :   (CLASSTYPE_USE_TEMPLATE (NODE) = 2)
    4882                 :            : 
    4883                 :            : #define DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 1)
    4884                 :            : #define SET_DECL_IMPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 1)
    4885                 :            : #define CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \
    4886                 :            :   (CLASSTYPE_USE_TEMPLATE (NODE) == 1)
    4887                 :            : #define SET_CLASSTYPE_IMPLICIT_INSTANTIATION(NODE) \
    4888                 :            :   (CLASSTYPE_USE_TEMPLATE (NODE) = 1)
    4889                 :            : 
    4890                 :            : #define DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) == 3)
    4891                 :            : #define SET_DECL_EXPLICIT_INSTANTIATION(NODE) (DECL_USE_TEMPLATE (NODE) = 3)
    4892                 :            : #define CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \
    4893                 :            :   (CLASSTYPE_USE_TEMPLATE (NODE) == 3)
    4894                 :            : #define SET_CLASSTYPE_EXPLICIT_INSTANTIATION(NODE) \
    4895                 :            :   (CLASSTYPE_USE_TEMPLATE (NODE) = 3)
    4896                 :            : 
    4897                 :            : /* Nonzero if DECL is a friend function which is an instantiation
    4898                 :            :    from the point of view of the compiler, but not from the point of
    4899                 :            :    view of the language.  For example given:
    4900                 :            :       template <class T> struct S { friend void f(T) {}; };
    4901                 :            :    the declaration of `void f(int)' generated when S<int> is
    4902                 :            :    instantiated will not be a DECL_TEMPLATE_INSTANTIATION, but will be
    4903                 :            :    a DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION.  */
    4904                 :            : #define DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION(DECL) \
    4905                 :            :   (DECL_LANG_SPECIFIC (DECL) && DECL_TEMPLATE_INFO (DECL) \
    4906                 :            :    && !DECL_USE_TEMPLATE (DECL))
    4907                 :            : 
    4908                 :            : /* Nonzero if DECL is a function generated from a function 'temploid',
    4909                 :            :    i.e. template, member of class template, or dependent friend.  */
    4910                 :            : #define DECL_TEMPLOID_INSTANTIATION(DECL)               \
    4911                 :            :   (DECL_TEMPLATE_INSTANTIATION (DECL)                   \
    4912                 :            :    || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (DECL))
    4913                 :            : 
    4914                 :            : /* Nonzero if DECL is either defined implicitly by the compiler or
    4915                 :            :    generated from a temploid.  */
    4916                 :            : #define DECL_GENERATED_P(DECL) \
    4917                 :            :   (DECL_TEMPLOID_INSTANTIATION (DECL) || DECL_DEFAULTED_FN (DECL))
    4918                 :            : 
    4919                 :            : /* Nonzero iff we are currently processing a declaration for an
    4920                 :            :    entity with its own template parameter list, and which is not a
    4921                 :            :    full specialization.  */
    4922                 :            : #define PROCESSING_REAL_TEMPLATE_DECL_P() \
    4923                 :            :   (!processing_template_parmlist \
    4924                 :            :    && processing_template_decl > template_class_depth (current_scope ()))
    4925                 :            : 
    4926                 :            : /* Nonzero if this VAR_DECL or FUNCTION_DECL has already been
    4927                 :            :    instantiated, i.e. its definition has been generated from the
    4928                 :            :    pattern given in the template.  */
    4929                 :            : #define DECL_TEMPLATE_INSTANTIATED(NODE) \
    4930                 :            :   DECL_LANG_FLAG_1 (VAR_OR_FUNCTION_DECL_CHECK (NODE))
    4931                 :            : 
    4932                 :            : /* We know what we're doing with this decl now.  */
    4933                 :            : #define DECL_INTERFACE_KNOWN(NODE) DECL_LANG_FLAG_5 (NODE)
    4934                 :            : 
    4935                 :            : /* DECL_EXTERNAL must be set on a decl until the decl is actually emitted,
    4936                 :            :    so that assemble_external will work properly.  So we have this flag to
    4937                 :            :    tell us whether the decl is really not external.
    4938                 :            : 
    4939                 :            :    This flag does not indicate whether or not the decl is defined in the
    4940                 :            :    current translation unit; it indicates whether or not we should emit the
    4941                 :            :    decl at the end of compilation if it is defined and needed.  */
    4942                 :            : #define DECL_NOT_REALLY_EXTERN(NODE) \
    4943                 :            :   (DECL_LANG_SPECIFIC (NODE)->u.base.not_really_extern)
    4944                 :            : 
    4945                 :            : #define DECL_REALLY_EXTERN(NODE) \
    4946                 :            :   (DECL_EXTERNAL (NODE)                         \
    4947                 :            :    && (!DECL_LANG_SPECIFIC (NODE) || !DECL_NOT_REALLY_EXTERN (NODE)))
    4948                 :            : 
    4949                 :            : /* A thunk is a stub function.
    4950                 :            : 
    4951                 :            :    A thunk is an alternate entry point for an ordinary FUNCTION_DECL.
    4952                 :            :    The address of the ordinary FUNCTION_DECL is given by the
    4953                 :            :    DECL_INITIAL, which is always an ADDR_EXPR whose operand is a
    4954                 :            :    FUNCTION_DECL.  The job of the thunk is to either adjust the this
    4955                 :            :    pointer before transferring control to the FUNCTION_DECL, or call
    4956                 :            :    FUNCTION_DECL and then adjust the result value. Note, the result
    4957                 :            :    pointer adjusting thunk must perform a call to the thunked
    4958                 :            :    function, (or be implemented via passing some invisible parameter
    4959                 :            :    to the thunked function, which is modified to perform the
    4960                 :            :    adjustment just before returning).
    4961                 :            : 
    4962                 :            :    A thunk may perform either, or both, of the following operations:
    4963                 :            : 
    4964                 :            :    o Adjust the this or result pointer by a constant offset.
    4965                 :            :    o Adjust the this or result pointer by looking up a vcall or vbase offset
    4966                 :            :      in the vtable.
    4967                 :            : 
    4968                 :            :    A this pointer adjusting thunk converts from a base to a derived
    4969                 :            :    class, and hence adds the offsets. A result pointer adjusting thunk
    4970                 :            :    converts from a derived class to a base, and hence subtracts the
    4971                 :            :    offsets.  If both operations are performed, then the constant
    4972                 :            :    adjustment is performed first for this pointer adjustment and last
    4973                 :            :    for the result pointer adjustment.
    4974                 :            : 
    4975                 :            :    The constant adjustment is given by THUNK_FIXED_OFFSET.  If the
    4976                 :            :    vcall or vbase offset is required, THUNK_VIRTUAL_OFFSET is
    4977                 :            :    used. For this pointer adjusting thunks, it is the vcall offset
    4978                 :            :    into the vtable.  For result pointer adjusting thunks it is the
    4979                 :            :    binfo of the virtual base to convert to.  Use that binfo's vbase
    4980                 :            :    offset.
    4981                 :            : 
    4982                 :            :    It is possible to have equivalent covariant thunks.  These are
    4983                 :            :    distinct virtual covariant thunks whose vbase offsets happen to
    4984                 :            :    have the same value.  THUNK_ALIAS is used to pick one as the
    4985                 :            :    canonical thunk, which will get all the this pointer adjusting
    4986                 :            :    thunks attached to it.  */
    4987                 :            : 
    4988                 :            : /* An integer indicating how many bytes should be subtracted from the
    4989                 :            :    this or result pointer when this function is called.  */
    4990                 :            : #define THUNK_FIXED_OFFSET(DECL) \
    4991                 :            :   (DECL_LANG_SPECIFIC (THUNK_FUNCTION_CHECK (DECL))->u.fn.u5.fixed_offset)
    4992                 :            : 
    4993                 :            : /* A tree indicating how to perform the virtual adjustment. For a this
    4994                 :            :    adjusting thunk it is the number of bytes to be added to the vtable
    4995                 :            :    to find the vcall offset. For a result adjusting thunk, it is the
    4996                 :            :    binfo of the relevant virtual base.  If NULL, then there is no
    4997                 :            :    virtual adjust.  (The vptr is always located at offset zero from
    4998                 :            :    the this or result pointer.)  (If the covariant type is within the
    4999                 :            :    class hierarchy being laid out, the vbase index is not yet known
    5000                 :            :    at the point we need to create the thunks, hence the need to use
    5001                 :            :    binfos.)  */
    5002                 :            : 
    5003                 :            : #define THUNK_VIRTUAL_OFFSET(DECL) \
    5004                 :            :   (LANG_DECL_MIN_CHECK (FUNCTION_DECL_CHECK (DECL))->access)
    5005                 :            : 
    5006                 :            : /* A thunk which is equivalent to another thunk.  */
    5007                 :            : #define THUNK_ALIAS(DECL) \
    5008                 :            :   (DECL_LANG_SPECIFIC (FUNCTION_DECL_CHECK (DECL))->u.min.template_info)
    5009                 :            : 
    5010                 :            : /* For thunk NODE, this is the FUNCTION_DECL thunked to.  It is
    5011                 :            :    possible for the target to be a thunk too.  */
    5012                 :            : #define THUNK_TARGET(NODE)                              \
    5013                 :            :   (LANG_DECL_FN_CHECK (NODE)->befriending_classes)
    5014                 :            : 
    5015                 :            : /* True for a SCOPE_REF iff the "template" keyword was used to
    5016                 :            :    indicate that the qualified name denotes a template.  */
    5017                 :            : #define QUALIFIED_NAME_IS_TEMPLATE(NODE) \
    5018                 :            :   (TREE_LANG_FLAG_1 (SCOPE_REF_CHECK (NODE)))
    5019                 :            : 
    5020                 :            : /* [coroutines]
    5021                 :            : */
    5022                 :            : 
    5023                 :            : /* True if NODE is a co-routine FUNCTION_DECL.  */
    5024                 :            : #define DECL_COROUTINE_P(NODE) \
    5025                 :            :   (LANG_DECL_FN_CHECK (DECL_COMMON_CHECK (NODE))->coroutine_p)
    5026                 :            : 
    5027                 :            : /* True for an OMP_ATOMIC that has dependent parameters.  These are stored
    5028                 :            :    as an expr in operand 1, and integer_zero_node or clauses in operand 0.  */
    5029                 :            : #define OMP_ATOMIC_DEPENDENT_P(NODE) \
    5030                 :            :   (TREE_CODE (TREE_OPERAND (OMP_ATOMIC_CHECK (NODE), 0)) == INTEGER_CST \
    5031                 :            :    || TREE_CODE (TREE_OPERAND (OMP_ATOMIC_CHECK (NODE), 0)) == OMP_CLAUSE)
    5032                 :            : 
    5033                 :            : /* Used while gimplifying continue statements bound to OMP_FOR nodes.  */
    5034                 :            : #define OMP_FOR_GIMPLIFYING_P(NODE) \
    5035                 :            :   (TREE_LANG_FLAG_0 (OMP_LOOPING_CHECK (NODE)))
    5036                 :            : 
    5037                 :            : /* A language-specific token attached to the OpenMP data clauses to
    5038                 :            :    hold code (or code fragments) related to ctors, dtors, and op=.
    5039                 :            :    See semantics.c for details.  */
    5040                 :            : #define CP_OMP_CLAUSE_INFO(NODE) \
    5041                 :            :   TREE_TYPE (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_PRIVATE, \
    5042                 :            :                                      OMP_CLAUSE__CONDTEMP_))
    5043                 :            : 
    5044                 :            : /* Nonzero if this transaction expression's body contains statements.  */
    5045                 :            : #define TRANSACTION_EXPR_IS_STMT(NODE) \
    5046                 :            :    TREE_LANG_FLAG_0 (TRANSACTION_EXPR_CHECK (NODE))
    5047                 :            : 
    5048                 :            : /* These macros provide convenient access to the various _STMT nodes
    5049                 :            :    created when parsing template declarations.  */
    5050                 :            : #define TRY_STMTS(NODE)         TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 0)
    5051                 :            : #define TRY_HANDLERS(NODE)      TREE_OPERAND (TRY_BLOCK_CHECK (NODE), 1)
    5052                 :            : 
    5053                 :            : #define EH_SPEC_STMTS(NODE)     TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 0)
    5054                 :            : #define EH_SPEC_RAISES(NODE)    TREE_OPERAND (EH_SPEC_BLOCK_CHECK (NODE), 1)
    5055                 :            : 
    5056                 :            : #define USING_STMT_NAMESPACE(NODE) TREE_OPERAND (USING_STMT_CHECK (NODE), 0)
    5057                 :            : 
    5058                 :            : /* Nonzero if this try block is a function try block.  */
    5059                 :            : #define FN_TRY_BLOCK_P(NODE)    TREE_LANG_FLAG_3 (TRY_BLOCK_CHECK (NODE))
    5060                 :            : #define HANDLER_PARMS(NODE)     TREE_OPERAND (HANDLER_CHECK (NODE), 0)
    5061                 :            : #define HANDLER_BODY(NODE)      TREE_OPERAND (HANDLER_CHECK (NODE), 1)
    5062                 :            : #define HANDLER_TYPE(NODE)      TREE_TYPE (HANDLER_CHECK (NODE))
    5063                 :            : 
    5064                 :            : /* CLEANUP_STMT accessors.  The statement(s) covered, the cleanup to run
    5065                 :            :    and the VAR_DECL for which this cleanup exists.  */
    5066                 :            : #define CLEANUP_BODY(NODE)      TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 0)
    5067                 :            : #define CLEANUP_EXPR(NODE)      TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 1)
    5068                 :            : #define CLEANUP_DECL(NODE)      TREE_OPERAND (CLEANUP_STMT_CHECK (NODE), 2)
    5069                 :            : 
    5070                 :            : /* IF_STMT accessors. These give access to the condition of the if
    5071                 :            :    statement, the then block of the if statement, and the else block
    5072                 :            :    of the if statement if it exists.  */
    5073                 :            : #define IF_COND(NODE)           TREE_OPERAND (IF_STMT_CHECK (NODE), 0)
    5074                 :            : #define THEN_CLAUSE(NODE)       TREE_OPERAND (IF_STMT_CHECK (NODE), 1)
    5075                 :            : #define ELSE_CLAUSE(NODE)       TREE_OPERAND (IF_STMT_CHECK (NODE), 2)
    5076                 :            : #define IF_SCOPE(NODE)          TREE_OPERAND (IF_STMT_CHECK (NODE), 3)
    5077                 :            : #define IF_STMT_CONSTEXPR_P(NODE) TREE_LANG_FLAG_0 (IF_STMT_CHECK (NODE))
    5078                 :            : 
    5079                 :            : /* Like PACK_EXPANSION_EXTRA_ARGS, for constexpr if.  IF_SCOPE is used while
    5080                 :            :    building an IF_STMT; IF_STMT_EXTRA_ARGS is used after it is complete.  */
    5081                 :            : #define IF_STMT_EXTRA_ARGS(NODE) IF_SCOPE (NODE)
    5082                 :            : 
    5083                 :            : /* WHILE_STMT accessors. These give access to the condition of the
    5084                 :            :    while statement and the body of the while statement, respectively.  */
    5085                 :            : #define WHILE_COND(NODE)        TREE_OPERAND (WHILE_STMT_CHECK (NODE), 0)
    5086                 :            : #define WHILE_BODY(NODE)        TREE_OPERAND (WHILE_STMT_CHECK (NODE), 1)
    5087                 :            : 
    5088                 :            : /* DO_STMT accessors. These give access to the condition of the do
    5089                 :            :    statement and the body of the do statement, respectively.  */
    5090                 :            : #define DO_COND(NODE)           TREE_OPERAND (DO_STMT_CHECK (NODE), 0)
    5091                 :            : #define DO_BODY(NODE)           TREE_OPERAND (DO_STMT_CHECK (NODE), 1)
    5092                 :            : 
    5093                 :            : /* FOR_STMT accessors. These give access to the init statement,
    5094                 :            :    condition, update expression, and body of the for statement,
    5095                 :            :    respectively.  */
    5096                 :            : #define FOR_INIT_STMT(NODE)     TREE_OPERAND (FOR_STMT_CHECK (NODE), 0)
    5097                 :            : #define FOR_COND(NODE)          TREE_OPERAND (FOR_STMT_CHECK (NODE), 1)
    5098                 :            : #define FOR_EXPR(NODE)          TREE_OPERAND (FOR_STMT_CHECK (NODE), 2)
    5099                 :            : #define FOR_BODY(NODE)          TREE_OPERAND (FOR_STMT_CHECK (NODE), 3)
    5100                 :            : #define FOR_SCOPE(NODE)         TREE_OPERAND (FOR_STMT_CHECK (NODE), 4)
    5101                 :            : 
    5102                 :            : /* RANGE_FOR_STMT accessors. These give access to the declarator,
    5103                 :            :    expression, body, and scope of the statement, respectively.  */
    5104                 :            : #define RANGE_FOR_DECL(NODE)    TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 0)
    5105                 :            : #define RANGE_FOR_EXPR(NODE)    TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 1)
    5106                 :            : #define RANGE_FOR_BODY(NODE)    TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 2)
    5107                 :            : #define RANGE_FOR_SCOPE(NODE)   TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 3)
    5108                 :            : #define RANGE_FOR_UNROLL(NODE)  TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 4)
    5109                 :            : #define RANGE_FOR_INIT_STMT(NODE) TREE_OPERAND (RANGE_FOR_STMT_CHECK (NODE), 5)
    5110                 :            : #define RANGE_FOR_IVDEP(NODE)   TREE_LANG_FLAG_6 (RANGE_FOR_STMT_CHECK (NODE))
    5111                 :            : 
    5112                 :            : #define SWITCH_STMT_COND(NODE)  TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 0)
    5113                 :            : #define SWITCH_STMT_BODY(NODE)  TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 1)
    5114                 :            : #define SWITCH_STMT_TYPE(NODE)  TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 2)
    5115                 :            : #define SWITCH_STMT_SCOPE(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 3)
    5116                 :            : /* True if there are case labels for all possible values of switch cond, either
    5117                 :            :    because there is a default: case label or because the case label ranges cover
    5118                 :            :    all values.  */
    5119                 :            : #define SWITCH_STMT_ALL_CASES_P(NODE) \
    5120                 :            :   TREE_LANG_FLAG_0 (SWITCH_STMT_CHECK (NODE))
    5121                 :            : /* True if the body of a switch stmt contains no BREAK_STMTs.  */
    5122                 :            : #define SWITCH_STMT_NO_BREAK_P(NODE) \
    5123                 :            :   TREE_LANG_FLAG_2 (SWITCH_STMT_CHECK (NODE))
    5124                 :            : 
    5125                 :            : /* STMT_EXPR accessor.  */
    5126                 :            : #define STMT_EXPR_STMT(NODE)    TREE_OPERAND (STMT_EXPR_CHECK (NODE), 0)
    5127                 :            : 
    5128                 :            : /* EXPR_STMT accessor. This gives the expression associated with an
    5129                 :            :    expression statement.  */
    5130                 :            : #define EXPR_STMT_EXPR(NODE)    TREE_OPERAND (EXPR_STMT_CHECK (NODE), 0)
    5131                 :            : 
    5132                 :            : /* True if this TARGET_EXPR was created by build_cplus_new, and so we can
    5133                 :            :    discard it if it isn't useful.  */
    5134                 :            : #define TARGET_EXPR_IMPLICIT_P(NODE) \
    5135                 :            :   TREE_LANG_FLAG_0 (TARGET_EXPR_CHECK (NODE))
    5136                 :            : 
    5137                 :            : /* True if this TARGET_EXPR is the result of list-initialization of a
    5138                 :            :    temporary.  */
    5139                 :            : #define TARGET_EXPR_LIST_INIT_P(NODE) \
    5140                 :            :   TREE_LANG_FLAG_1 (TARGET_EXPR_CHECK (NODE))
    5141                 :            : 
    5142                 :            : /* True if this TARGET_EXPR expresses direct-initialization of an object
    5143                 :            :    to be named later.  */
    5144                 :            : #define TARGET_EXPR_DIRECT_INIT_P(NODE) \
    5145                 :            :   TREE_LANG_FLAG_2 (TARGET_EXPR_CHECK (NODE))
    5146                 :            : 
    5147                 :            : /* True if NODE is a TARGET_EXPR that just expresses a copy of its INITIAL; if
    5148                 :            :    the initializer has void type, it's doing something more complicated.  */
    5149                 :            : #define SIMPLE_TARGET_EXPR_P(NODE)                              \
    5150                 :            :   (TREE_CODE (NODE) == TARGET_EXPR                              \
    5151                 :            :    && TARGET_EXPR_INITIAL (NODE)                                \
    5152                 :            :    && !VOID_TYPE_P (TREE_TYPE (TARGET_EXPR_INITIAL (NODE))))
    5153                 :            : 
    5154                 :            : /* True if EXPR expresses direct-initialization of a TYPE.  */
    5155                 :            : #define DIRECT_INIT_EXPR_P(TYPE,EXPR)                                   \
    5156                 :            :   (TREE_CODE (EXPR) == TARGET_EXPR && TREE_LANG_FLAG_2 (EXPR)           \
    5157                 :            :    && same_type_ignoring_top_level_qualifiers_p (TYPE, TREE_TYPE (EXPR)))
    5158                 :            : 
    5159                 :            : /* True if this CONVERT_EXPR is for a conversion to virtual base in
    5160                 :            :    an NSDMI, and should be re-evaluated when used in a constructor.  */
    5161                 :            : #define CONVERT_EXPR_VBASE_PATH(NODE) \
    5162                 :            :   TREE_LANG_FLAG_0 (CONVERT_EXPR_CHECK (NODE))
    5163                 :            : 
    5164                 :            : /* True if SIZEOF_EXPR argument is type.  */
    5165                 :            : #define SIZEOF_EXPR_TYPE_P(NODE) \
    5166                 :            :   TREE_LANG_FLAG_0 (SIZEOF_EXPR_CHECK (NODE))
    5167                 :            : 
    5168                 :            : /* True if the ALIGNOF_EXPR was spelled "alignof".  */
    5169                 :            : #define ALIGNOF_EXPR_STD_P(NODE) \
    5170                 :            :   TREE_LANG_FLAG_0 (ALIGNOF_EXPR_CHECK (NODE))
    5171                 :            : 
    5172                 :            : /* OMP_DEPOBJ accessors. These give access to the depobj expression of the
    5173                 :            :    #pragma omp depobj directive and the clauses, respectively.  If
    5174                 :            :    OMP_DEPOBJ_CLAUSES is INTEGER_CST, it is instead the update clause kind
    5175                 :            :    or OMP_CLAUSE_DEPEND_LAST for destroy clause.  */
    5176                 :            : #define OMP_DEPOBJ_DEPOBJ(NODE)  TREE_OPERAND (OMP_DEPOBJ_CHECK (NODE), 0)
    5177                 :            : #define OMP_DEPOBJ_CLAUSES(NODE) TREE_OPERAND (OMP_DEPOBJ_CHECK (NODE), 1)
    5178                 :            : 
    5179                 :            : /* An enumeration of the kind of tags that C++ accepts.  */
    5180                 :            : enum tag_types {
    5181                 :            :   none_type = 0, /* Not a tag type.  */
    5182                 :            :   record_type,   /* "struct" types.  */
    5183                 :            :   class_type,    /* "class" types.  */
    5184                 :            :   union_type,    /* "union" types.  */
    5185                 :            :   enum_type,     /* "enum" types.  */
    5186                 :            :   typename_type, /* "typename" types.  */
    5187                 :            :   scope_type     /* namespace or tagged type name followed by :: */
    5188                 :            : };
    5189                 :            : 
    5190                 :            : /* The various kinds of lvalues we distinguish.  */
    5191                 :            : enum cp_lvalue_kind_flags {
    5192                 :            :   clk_none = 0,     /* Things that are not an lvalue.  */
    5193                 :            :   clk_ordinary = 1, /* An ordinary lvalue.  */
    5194                 :            :   clk_rvalueref = 2,/* An xvalue (rvalue formed using an rvalue reference) */
    5195                 :            :   clk_class = 4,    /* A prvalue of class or array type.  */
    5196                 :            :   clk_bitfield = 8, /* An lvalue for a bit-field.  */
    5197                 :            :   clk_packed = 16   /* An lvalue for a packed field.  */
    5198                 :            : };
    5199                 :            : 
    5200                 :            : /* This type is used for parameters and variables which hold
    5201                 :            :    combinations of the flags in enum cp_lvalue_kind_flags.  */
    5202                 :            : typedef int cp_lvalue_kind;
    5203                 :            : 
    5204                 :            : /* Various kinds of template specialization, instantiation, etc.  */
    5205                 :            : enum tmpl_spec_kind {
    5206                 :            :   tsk_none,                /* Not a template at all.  */
    5207                 :            :   tsk_invalid_member_spec, /* An explicit member template
    5208                 :            :                               specialization, but the enclosing
    5209                 :            :                               classes have not all been explicitly
    5210                 :            :                               specialized.  */
    5211                 :            :   tsk_invalid_expl_inst,   /* An explicit instantiation containing
    5212                 :            :                               template parameter lists.  */
    5213                 :            :   tsk_excessive_parms,     /* A template declaration with too many
    5214                 :            :                               template parameter lists.  */
    5215                 :            :   tsk_insufficient_parms,  /* A template declaration with too few
    5216                 :            :                               parameter lists.  */
    5217                 :            :   tsk_template,            /* A template declaration.  */
    5218                 :            :   tsk_expl_spec,           /* An explicit specialization.  */
    5219                 :            :   tsk_expl_inst            /* An explicit instantiation.  */
    5220                 :            : };
    5221                 :            : 
    5222                 :            : /* The various kinds of access.  BINFO_ACCESS depends on these being
    5223                 :            :    two bit quantities.  The numerical values are important; they are
    5224                 :            :    used to initialize RTTI data structures, so changing them changes
    5225                 :            :    the ABI.  */
    5226                 :            : enum access_kind {
    5227                 :            :   ak_none = 0,             /* Inaccessible.  */
    5228                 :            :   ak_public = 1,           /* Accessible, as a `public' thing.  */
    5229                 :            :   ak_protected = 2,        /* Accessible, as a `protected' thing.  */
    5230                 :            :   ak_private = 3           /* Accessible, as a `private' thing.  */
    5231                 :            : };
    5232                 :            : 
    5233                 :            : /* The various kinds of special functions.  If you add to this list,
    5234                 :            :    you should update special_function_p as well.  */
    5235                 :            : enum special_function_kind {
    5236                 :            :   sfk_none = 0,            /* Not a special function.  This enumeral
    5237                 :            :                               must have value zero; see
    5238                 :            :                               special_function_p.  */
    5239                 :            :   /* The following are ordered, for use by member synthesis fns.  */
    5240                 :            :   sfk_destructor,          /* A destructor.  */
    5241                 :            :   sfk_constructor,         /* A constructor.  */
    5242                 :            :   sfk_inheriting_constructor, /* An inheriting constructor */
    5243                 :            :   sfk_copy_constructor,    /* A copy constructor.  */
    5244                 :            :   sfk_move_constructor,    /* A move constructor.  */
    5245                 :            :   sfk_copy_assignment,     /* A copy assignment operator.  */
    5246                 :            :   sfk_move_assignment,     /* A move assignment operator.  */
    5247                 :            :   /* The following are unordered.  */
    5248                 :            :   sfk_complete_destructor, /* A destructor for complete objects.  */
    5249                 :            :   sfk_base_destructor,     /* A destructor for base subobjects.  */
    5250                 :            :   sfk_deleting_destructor, /* A destructor for complete objects that
    5251                 :            :                               deletes the object after it has been
    5252                 :            :                               destroyed.  */
    5253                 :            :   sfk_conversion,          /* A conversion operator.  */
    5254                 :            :   sfk_deduction_guide,     /* A class template deduction guide.  */
    5255                 :            :   sfk_comparison,          /* A comparison operator (e.g. ==, <, <=>).  */
    5256                 :            :   sfk_virtual_destructor   /* Used by member synthesis fns.  */
    5257                 :            : };
    5258                 :            : 
    5259                 :            : /* The various kinds of linkage.  From [basic.link],
    5260                 :            : 
    5261                 :            :       A name is said to have linkage when it might denote the same
    5262                 :            :       object, reference, function, type, template, namespace or value
    5263                 :            :       as a name introduced in another scope:
    5264                 :            : 
    5265                 :            :       -- When a name has external linkage, the entity it denotes can
    5266                 :            :          be referred to from scopes of other translation units or from
    5267                 :            :          other scopes of the same translation unit.
    5268                 :            : 
    5269                 :            :       -- When a name has internal linkage, the entity it denotes can
    5270                 :            :          be referred to by names from other scopes in the same
    5271                 :            :          translation unit.
    5272                 :            : 
    5273                 :            :       -- When a name has no linkage, the entity it denotes cannot be
    5274                 :            :          referred to by names from other scopes.  */
    5275                 :            : 
    5276                 :            : enum linkage_kind {
    5277                 :            :   lk_none,                      /* No linkage.  */
    5278                 :            :   lk_internal,                  /* Internal linkage.  */
    5279                 :            :   lk_external                   /* External linkage.  */
    5280                 :            : };
    5281                 :            : 
    5282                 :            : enum duration_kind {
    5283                 :            :   dk_static,
    5284                 :            :   dk_thread,
    5285                 :            :   dk_auto,
    5286                 :            :   dk_dynamic
    5287                 :            : };
    5288                 :            : 
    5289                 :            : /* Bitmask flags to control type substitution.  */
    5290                 :            : enum tsubst_flags {
    5291                 :            :   tf_none = 0,                   /* nothing special */
    5292                 :            :   tf_error = 1 << 0,               /* give error messages  */
    5293                 :            :   tf_warning = 1 << 1,             /* give warnings too  */
    5294                 :            :   tf_ignore_bad_quals = 1 << 2,    /* ignore bad cvr qualifiers */
    5295                 :            :   tf_keep_type_decl = 1 << 3,      /* retain typedef type decls
    5296                 :            :                                     (make_typename_type use) */
    5297                 :            :   tf_ptrmem_ok = 1 << 4,   /* pointers to member ok (internal
    5298                 :            :                                     instantiate_type use) */
    5299                 :            :   tf_user = 1 << 5,                /* found template must be a user template
    5300                 :            :                                     (lookup_template_class use) */
    5301                 :            :   tf_conv = 1 << 6,                /* We are determining what kind of
    5302                 :            :                                     conversion might be permissible,
    5303                 :            :                                     not actually performing the
    5304                 :            :                                     conversion.  */
    5305                 :            :   tf_decltype = 1 << 7,          /* We are the operand of decltype.
    5306                 :            :                                     Used to implement the special rules
    5307                 :            :                                     for calls in decltype (5.2.2/11).  */
    5308                 :            :   tf_partial = 1 << 8,             /* Doing initial explicit argument
    5309                 :            :                                     substitution in fn_type_unification.  */
    5310                 :            :   tf_fndecl_type = 1 << 9,   /* Substituting the type of a function
    5311                 :            :                                 declaration.  */
    5312                 :            :   tf_no_cleanup = 1 << 10,   /* Do not build a cleanup
    5313                 :            :                                 (build_target_expr and friends) */
    5314                 :            :   tf_norm = 1 << 11,               /* Build diagnostic information during
    5315                 :            :                                     constraint normalization.  */
    5316                 :            :   /* Convenient substitution flags combinations.  */
    5317                 :            :   tf_warning_or_error = tf_warning | tf_error
    5318                 :            : };
    5319                 :            : 
    5320                 :            : /* This type is used for parameters and variables which hold
    5321                 :            :    combinations of the flags in enum tsubst_flags.  */
    5322                 :            : typedef int tsubst_flags_t;
    5323                 :            : 
    5324                 :            : /* The kind of checking we can do looking in a class hierarchy.  */
    5325                 :            : enum base_access_flags {
    5326                 :            :   ba_any = 0,  /* Do not check access, allow an ambiguous base,
    5327                 :            :                       prefer a non-virtual base */
    5328                 :            :   ba_unique = 1 << 0,  /* Must be a unique base.  */
    5329                 :            :   ba_check_bit = 1 << 1,   /* Check access.  */
    5330                 :            :   ba_check = ba_unique | ba_check_bit,
    5331                 :            :   ba_ignore_scope = 1 << 2 /* Ignore access allowed by local scope.  */
    5332                 :            : };
    5333                 :            : 
    5334                 :            : /* This type is used for parameters and variables which hold
    5335                 :            :    combinations of the flags in enum base_access_flags.  */
    5336                 :            : typedef int base_access;
    5337                 :            : 
    5338                 :            : /* The various kinds of access check during parsing.  */
    5339                 :            : enum deferring_kind {
    5340                 :            :   dk_no_deferred = 0, /* Check access immediately */
    5341                 :            :   dk_deferred = 1,    /* Deferred check */
    5342                 :            :   dk_no_check = 2     /* No access check */
    5343                 :            : };
    5344                 :            : 
    5345                 :            : /* The kind of base we can find, looking in a class hierarchy.
    5346                 :            :    Values <0 indicate we failed.  */
    5347                 :            : enum base_kind {
    5348                 :            :   bk_inaccessible = -3,   /* The base is inaccessible */
    5349                 :            :   bk_ambig = -2,          /* The base is ambiguous */
    5350                 :            :   bk_not_base = -1,       /* It is not a base */
    5351                 :            :   bk_same_type = 0,       /* It is the same type */
    5352                 :            :   bk_proper_base = 1,     /* It is a proper base */
    5353                 :            :   bk_via_virtual = 2      /* It is a proper base, but via a virtual
    5354                 :            :                              path. This might not be the canonical
    5355                 :            :                              binfo.  */
    5356                 :            : };
    5357                 :            : 
    5358                 :            : /* Node for "pointer to (virtual) function".
    5359                 :            :    This may be distinct from ptr_type_node so gdb can distinguish them.  */
    5360                 :            : #define vfunc_ptr_type_node  vtable_entry_type
    5361                 :            : 
    5362                 :            : 
    5363                 :            : /* For building calls to `delete'.  */
    5364                 :            : extern GTY(()) tree integer_two_node;
    5365                 :            : 
    5366                 :            : /* The number of function bodies which we are currently processing.
    5367                 :            :    (Zero if we are at namespace scope, one inside the body of a
    5368                 :            :    function, two inside the body of a function in a local class, etc.)  */
    5369                 :            : extern int function_depth;
    5370                 :            : 
    5371                 :            : /* Nonzero if we are inside eq_specializations, which affects comparison of
    5372                 :            :    PARM_DECLs in cp_tree_equal.  */
    5373                 :            : extern int comparing_specializations;
    5374                 :            : 
    5375                 :            : /* In parser.c.  */
    5376                 :            : 
    5377                 :            : /* Nonzero if we are parsing an unevaluated operand: an operand to
    5378                 :            :    sizeof, typeof, or alignof.  This is a count since operands to
    5379                 :            :    sizeof can be nested.  */
    5380                 :            : 
    5381                 :            : extern int cp_unevaluated_operand;
    5382                 :            : 
    5383                 :            : /* RAII class used to inhibit the evaluation of operands during parsing
    5384                 :            :    and template instantiation. Evaluation warnings are also inhibited. */
    5385                 :            : 
    5386                 :            : class cp_unevaluated
    5387                 :            : {
    5388                 :            : public:
    5389                 :            :   cp_unevaluated ();
    5390                 :            :   ~cp_unevaluated ();
    5391                 :            : };
    5392                 :            : 
    5393                 :            : /* The reverse: an RAII class used for nested contexts that are evaluated even
    5394                 :            :    if the enclosing context is not.  */
    5395                 :            : 
    5396                 :            : class cp_evaluated
    5397                 :            : {
    5398                 :            : public:
    5399                 :            :   int uneval;
    5400                 :            :   int inhibit;
    5401                 :  351602541 :   cp_evaluated ()
    5402                 :  351602541 :     : uneval(cp_unevaluated_operand), inhibit(c_inhibit_evaluation_warnings)
    5403                 :  351602541 :   { cp_unevaluated_operand = c_inhibit_evaluation_warnings = 0; }
    5404                 :  351602541 :   ~cp_evaluated ()
    5405                 :  351602541 :   { cp_unevaluated_operand = uneval;
    5406                 :  351602541 :     c_inhibit_evaluation_warnings = inhibit; }
    5407                 :            : };
    5408                 :            : 
    5409                 :            : /* in pt.c  */
    5410                 :            : 
    5411                 :            : /* These values are used for the `STRICT' parameter to type_unification and
    5412                 :            :    fn_type_unification.  Their meanings are described with the
    5413                 :            :    documentation for fn_type_unification.  */
    5414                 :            : 
    5415                 :            : enum unification_kind_t {
    5416                 :            :   DEDUCE_CALL,
    5417                 :            :   DEDUCE_CONV,
    5418                 :            :   DEDUCE_EXACT
    5419                 :            : };
    5420                 :            : 
    5421                 :            : // An RAII class used to create a new pointer map for local
    5422                 :            : // specializations. When the stack goes out of scope, the
    5423                 :            : // previous pointer map is restored.
    5424                 :            : enum lss_policy { lss_blank, lss_copy };
    5425                 :            : class local_specialization_stack
    5426                 :            : {
    5427                 :            : public:
    5428                 :            :   local_specialization_stack (lss_policy = lss_blank);
    5429                 :            :   ~local_specialization_stack ();
    5430                 :            : 
    5431                 :            :   hash_map<tree, tree> *saved;
    5432                 :            : };
    5433                 :            : 
    5434                 :            : /* in class.c */
    5435                 :            : 
    5436                 :            : extern int current_class_depth;
    5437                 :            : 
    5438                 :            : /* in decl.c */
    5439                 :            : 
    5440                 :            : /* An array of static vars & fns.  */
    5441                 :            : extern GTY(()) vec<tree, va_gc> *static_decls;
    5442                 :            : 
    5443                 :            : /* An array of vtable-needing types that have no key function, or have
    5444                 :            :    an emitted key function.  */
    5445                 :            : extern GTY(()) vec<tree, va_gc> *keyed_classes;
    5446                 :            : 
    5447                 :            : /* Here's where we control how name mangling takes place.  */
    5448                 :            : 
    5449                 :            : /* Cannot use '$' up front, because this confuses gdb
    5450                 :            :    (names beginning with '$' are gdb-local identifiers).
    5451                 :            : 
    5452                 :            :    Note that all forms in which the '$' is significant are long enough
    5453                 :            :    for direct indexing (meaning that if we know there is a '$'
    5454                 :            :    at a particular location, we can index into the string at
    5455                 :            :    any other location that provides distinguishing characters).  */
    5456                 :            : 
    5457                 :            : /* Define NO_DOT_IN_LABEL in your favorite tm file if your assembler
    5458                 :            :    doesn't allow '.' in symbol names.  */
    5459                 :            : #ifndef NO_DOT_IN_LABEL
    5460                 :            : 
    5461                 :            : #define JOINER '.'
    5462                 :            : 
    5463                 :            : #define AUTO_TEMP_NAME "_.tmp_"
    5464                 :            : #define VFIELD_BASE ".vf"
    5465                 :            : #define VFIELD_NAME "_vptr."
    5466                 :            : #define VFIELD_NAME_FORMAT "_vptr.%s"
    5467                 :            : 
    5468                 :            : #else /* NO_DOT_IN_LABEL */
    5469                 :            : 
    5470                 :            : #ifndef NO_DOLLAR_IN_LABEL
    5471                 :            : 
    5472                 :            : #define JOINER '$'
    5473                 :            : 
    5474                 :            : #define AUTO_TEMP_NAME "_$tmp_"
    5475                 :            : #define VFIELD_BASE "$vf"
    5476                 :            : #define VFIELD_NAME "_vptr$"
    5477                 :            : #define VFIELD_NAME_FORMAT "_vptr$%s"
    5478                 :            : 
    5479                 :            : #else /* NO_DOLLAR_IN_LABEL */
    5480                 :            : 
    5481                 :            : #define VTABLE_NAME "__vt_"
    5482                 :            : #define VTABLE_NAME_P(ID_NODE) \
    5483                 :            :   (!strncmp (IDENTIFIER_POINTER (ID_NODE), VTABLE_NAME, \
    5484                 :            :              sizeof (VTABLE_NAME) - 1))
    5485                 :            : #define VFIELD_BASE "__vfb"
    5486                 :            : #define VFIELD_NAME "__vptr_"
    5487                 :            : #define VFIELD_NAME_P(ID_NODE) \
    5488                 :            :   (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, \
    5489                 :            :             sizeof (VFIELD_NAME) - 1))
    5490                 :            : #define VFIELD_NAME_FORMAT "__vptr_%s"
    5491                 :            : 
    5492                 :            : #endif  /* NO_DOLLAR_IN_LABEL */
    5493                 :            : #endif  /* NO_DOT_IN_LABEL */
    5494                 :            : 
    5495                 :            : #define UDLIT_OP_ANSI_PREFIX "operator\"\""
    5496                 :            : #define UDLIT_OP_ANSI_FORMAT UDLIT_OP_ANSI_PREFIX "%s"
    5497                 :            : #define UDLIT_OP_MANGLED_PREFIX "li"
    5498                 :            : #define UDLIT_OP_MANGLED_FORMAT UDLIT_OP_MANGLED_PREFIX "%s"
    5499                 :            : #define UDLIT_OPER_P(ID_NODE) \
    5500                 :            :   (!strncmp (IDENTIFIER_POINTER (ID_NODE), \
    5501                 :            :              UDLIT_OP_ANSI_PREFIX, \
    5502                 :            :              sizeof (UDLIT_OP_ANSI_PREFIX) - 1))
    5503                 :            : #define UDLIT_OP_SUFFIX(ID_NODE) \
    5504                 :            :   (IDENTIFIER_POINTER (ID_NODE) + sizeof (UDLIT_OP_ANSI_PREFIX) - 1)
    5505                 :            : 
    5506                 :            : #if !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL)
    5507                 :            : 
    5508                 :            : #define VTABLE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == 'v' \
    5509                 :            :   && IDENTIFIER_POINTER (ID_NODE)[2] == 't' \
    5510                 :            :   && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER)
    5511                 :            : 
    5512                 :            : #define VFIELD_NAME_P(ID_NODE) \
    5513                 :            :   (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, sizeof(VFIELD_NAME)-1))
    5514                 :            : 
    5515                 :            : #endif /* !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL) */
    5516                 :            : 
    5517                 :            : 
    5518                 :            : /* Nonzero if we're done parsing and into end-of-file activities.
    5519                 :            :    Two if we're done with front-end processing.  */
    5520                 :            : 
    5521                 :            : extern int at_eof;
    5522                 :            : 
    5523                 :            : /* True if note_mangling_alias should enqueue mangling aliases for
    5524                 :            :    later generation, rather than emitting them right away.  */
    5525                 :            : 
    5526                 :            : extern bool defer_mangling_aliases;
    5527                 :            : 
    5528                 :            : /* True if noexcept is part of the type (i.e. in C++17).  */
    5529                 :            : 
    5530                 :            : extern bool flag_noexcept_type;
    5531                 :            : 
    5532                 :            : /* A list of namespace-scope objects which have constructors or
    5533                 :            :    destructors which reside in the global scope.  The decl is stored
    5534                 :            :    in the TREE_VALUE slot and the initializer is stored in the
    5535                 :            :    TREE_PURPOSE slot.  */
    5536                 :            : extern GTY(()) tree static_aggregates;
    5537                 :            : /* Likewise, for thread local storage.  */
    5538                 :            : extern GTY(()) tree tls_aggregates;
    5539                 :            : 
    5540                 :            : enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, TYPENAME_FLAG };
    5541                 :            : 
    5542                 :            : /* These are uses as bits in flags passed to various functions to
    5543                 :            :    control their behavior.  Despite the LOOKUP_ prefix, many of these
    5544                 :            :    do not control name lookup.  ??? Functions using these flags should
    5545                 :            :    probably be modified to accept explicit boolean flags for the
    5546                 :            :    behaviors relevant to them.  */
    5547                 :            : /* Check for access violations.  */
    5548                 :            : #define LOOKUP_PROTECT (1 << 0)
    5549                 :            : #define LOOKUP_NORMAL (LOOKUP_PROTECT)
    5550                 :            : /* Even if the function found by lookup is a virtual function, it
    5551                 :            :    should be called directly.  */
    5552                 :            : #define LOOKUP_NONVIRTUAL (1 << 1)
    5553                 :            : /* Non-converting (i.e., "explicit") constructors are not tried.  This flag
    5554                 :            :    indicates that we are not performing direct-initialization.  */
    5555                 :            : #define LOOKUP_ONLYCONVERTING (1 << 2)
    5556                 :            : #define LOOKUP_IMPLICIT (LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING)
    5557                 :            : /* If a temporary is created, it should be created so that it lives
    5558                 :            :    as long as the current variable bindings; otherwise it only lives
    5559                 :            :    until the end of the complete-expression.  It also forces
    5560                 :            :    direct-initialization in cases where other parts of the compiler
    5561                 :            :    have already generated a temporary, such as reference
    5562                 :            :    initialization and the catch parameter.  */
    5563                 :            : #define DIRECT_BIND (1 << 3)
    5564                 :            : /* We're performing a user-defined conversion, so more user-defined
    5565                 :            :    conversions are not permitted (only built-in conversions).  */
    5566                 :            : #define LOOKUP_NO_CONVERSION (1 << 4)
    5567                 :            : /* The user has explicitly called a destructor.  (Therefore, we do
    5568                 :            :    not need to check that the object is non-NULL before calling the
    5569                 :            :    destructor.)  */
    5570                 :            : #define LOOKUP_DESTRUCTOR (1 << 5)
    5571                 :            : /* Do not permit references to bind to temporaries.  */
    5572                 :            : #define LOOKUP_NO_TEMP_BIND (1 << 6)
    5573                 :            : /* Do not accept objects, and possibly namespaces.  */
    5574                 :            : #define LOOKUP_PREFER_TYPES (1 << 7)
    5575                 :            : /* Do not accept objects, and possibly types.   */
    5576                 :            : #define LOOKUP_PREFER_NAMESPACES (1 << 8)
    5577                 :            : /* Accept types or namespaces.  */
    5578                 :            : #define LOOKUP_PREFER_BOTH (LOOKUP_PREFER_TYPES | LOOKUP_PREFER_NAMESPACES)
    5579                 :            : /* Return friend declarations and un-declared builtin functions.
    5580                 :            :    (Normally, these entities are registered in the symbol table, but
    5581                 :            :    not found by lookup.)  */
    5582                 :            : #define LOOKUP_HIDDEN (LOOKUP_PREFER_NAMESPACES << 1)
    5583                 :            : /* We're trying to treat an lvalue as an rvalue.  */
    5584                 :            : #define LOOKUP_PREFER_RVALUE (LOOKUP_HIDDEN << 1)
    5585                 :            : /* We're inside an init-list, so narrowing conversions are ill-formed.  */
    5586                 :            : #define LOOKUP_NO_NARROWING (LOOKUP_PREFER_RVALUE << 1)
    5587                 :            : /* We're looking up a constructor for list-initialization.  */
    5588                 :            : #define LOOKUP_LIST_INIT_CTOR (LOOKUP_NO_NARROWING << 1)
    5589                 :            : /* This is the first parameter of a copy constructor.  */
    5590                 :            : #define LOOKUP_COPY_PARM (LOOKUP_LIST_INIT_CTOR << 1)
    5591                 :            : /* We only want to consider list constructors.  */
    5592                 :            : #define LOOKUP_LIST_ONLY (LOOKUP_COPY_PARM << 1)
    5593                 :            : /* Return after determining which function to call and checking access.
    5594                 :            :    Used by sythesized_method_walk to determine which functions will
    5595                 :            :    be called to initialize subobjects, in order to determine exception
    5596                 :            :    specification and possible implicit delete.
    5597                 :            :    This is kind of a hack, but exiting early avoids problems with trying
    5598                 :            :    to perform argument conversions when the class isn't complete yet.  */
    5599                 :            : #define LOOKUP_SPECULATIVE (LOOKUP_LIST_ONLY << 1)
    5600                 :            : /* Used by calls from defaulted functions to limit the overload set to avoid
    5601                 :            :    cycles trying to declare them (core issue 1092).  */
    5602                 :            : #define LOOKUP_DEFAULTED (LOOKUP_SPECULATIVE << 1)
    5603                 :            : /* Used in calls to store_init_value to suppress its usual call to
    5604                 :            :    digest_init.  */
    5605                 :            : #define LOOKUP_ALREADY_DIGESTED (LOOKUP_DEFAULTED << 1)
    5606                 :            : /* An instantiation with explicit template arguments.  */
    5607                 :            : #define LOOKUP_EXPLICIT_TMPL_ARGS (LOOKUP_ALREADY_DIGESTED << 1)
    5608                 :            : /* Like LOOKUP_NO_TEMP_BIND, but also prevent binding to xvalues.  */
    5609                 :            : #define LOOKUP_NO_RVAL_BIND (LOOKUP_EXPLICIT_TMPL_ARGS << 1)
    5610                 :            : /* Used by case_conversion to disregard non-integral conversions.  */
    5611                 :            : #define LOOKUP_NO_NON_INTEGRAL (LOOKUP_NO_RVAL_BIND << 1)
    5612                 :            : /* Used for delegating constructors in order to diagnose self-delegation.  */
    5613                 :            : #define LOOKUP_DELEGATING_CONS (LOOKUP_NO_NON_INTEGRAL << 1)
    5614                 :            : /* Allow initialization of a flexible array members.  */
    5615                 :            : #define LOOKUP_ALLOW_FLEXARRAY_INIT (LOOKUP_DELEGATING_CONS << 1)
    5616                 :            : /* Require constant initialization of a non-constant variable.  */
    5617                 :            : #define LOOKUP_CONSTINIT (LOOKUP_ALLOW_FLEXARRAY_INIT << 1)
    5618                 :            : /* We're looking for either a rewritten comparison operator candidate or the
    5619                 :            :    operator to use on the former's result.  We distinguish between the two by
    5620                 :            :    knowing that comparisons other than == and <=> must be the latter, as must
    5621                 :            :    a <=> expression trying to rewrite to <=> without reversing.  */
    5622                 :            : #define LOOKUP_REWRITTEN (LOOKUP_CONSTINIT << 1)
    5623                 :            : /* Reverse the order of the two arguments for comparison rewriting.  First we
    5624                 :            :    swap the arguments in add_operator_candidates, then we swap the conversions
    5625                 :            :    in add_candidate (so that they correspond to the original order of the
    5626                 :            :    args), then we swap the conversions back in build_new_op_1 (so they
    5627                 :            :    correspond to the order of the args in the candidate).  */
    5628                 :            : #define LOOKUP_REVERSED (LOOKUP_REWRITTEN << 1)
    5629                 :            : /* We're initializing an aggregate from a parenthesized list of values.  */
    5630                 :            : #define LOOKUP_AGGREGATE_PAREN_INIT (LOOKUP_REVERSED << 1)
    5631                 :            : 
    5632                 :            : #define LOOKUP_NAMESPACES_ONLY(F)  \
    5633                 :            :   (((F) & LOOKUP_PREFER_NAMESPACES) && !((F) & LOOKUP_PREFER_TYPES))
    5634                 :            : #define LOOKUP_TYPES_ONLY(F)  \
    5635                 :            :   (!((F) & LOOKUP_PREFER_NAMESPACES) && ((F) & LOOKUP_PREFER_TYPES))
    5636                 :            : #define LOOKUP_QUALIFIERS_ONLY(F)     ((F) & LOOKUP_PREFER_BOTH)
    5637                 :            : 
    5638                 :            : 
    5639                 :            : /* These flags are used by the conversion code.
    5640                 :            :    CONV_IMPLICIT   :  Perform implicit conversions (standard and user-defined).
    5641                 :            :    CONV_STATIC     :  Perform the explicit conversions for static_cast.
    5642                 :            :    CONV_CONST      :  Perform the explicit conversions for const_cast.
    5643                 :            :    CONV_REINTERPRET:  Perform the explicit conversions for reinterpret_cast.
    5644                 :            :    CONV_PRIVATE    :  Perform upcasts to private bases.
    5645                 :            :    CONV_FORCE_TEMP :  Require a new temporary when converting to the same
    5646                 :            :                       aggregate type.  */
    5647                 :            : 
    5648                 :            : #define CONV_IMPLICIT    1
    5649                 :            : #define CONV_STATIC      2
    5650                 :            : #define CONV_CONST       4
    5651                 :            : #define CONV_REINTERPRET 8
    5652                 :            : #define CONV_PRIVATE     16
    5653                 :            : #define CONV_FORCE_TEMP  32
    5654                 :            : #define CONV_FOLD        64
    5655                 :            : #define CONV_OLD_CONVERT (CONV_IMPLICIT | CONV_STATIC | CONV_CONST \
    5656                 :            :                           | CONV_REINTERPRET)
    5657                 :            : #define CONV_C_CAST      (CONV_IMPLICIT | CONV_STATIC | CONV_CONST \
    5658                 :            :                           | CONV_REINTERPRET | CONV_PRIVATE | CONV_FORCE_TEMP)
    5659                 :            : #define CONV_BACKEND_CONVERT (CONV_OLD_CONVERT | CONV_FOLD)
    5660                 :            : 
    5661                 :            : /* Used by build_expr_type_conversion to indicate which types are
    5662                 :            :    acceptable as arguments to the expression under consideration.  */
    5663                 :            : 
    5664                 :            : #define WANT_INT        1 /* integer types, including bool */
    5665                 :            : #define WANT_FLOAT      2 /* floating point types */
    5666                 :            : #define WANT_ENUM       4 /* enumerated types */
    5667                 :            : #define WANT_POINTER    8 /* pointer types */
    5668                 :            : #define WANT_NULL      16 /* null pointer constant */
    5669                 :            : #define WANT_VECTOR_OR_COMPLEX 32 /* vector or complex types */
    5670                 :            : #define WANT_ARITH      (WANT_INT | WANT_FLOAT | WANT_VECTOR_OR_COMPLEX)
    5671                 :            : 
    5672                 :            : /* Used with comptypes, and related functions, to guide type
    5673                 :            :    comparison.  */
    5674                 :            : 
    5675                 :            : #define COMPARE_STRICT        0 /* Just check if the types are the
    5676                 :            :                                    same.  */
    5677                 :            : #define COMPARE_BASE          1 /* Check to see if the second type is
    5678                 :            :                                    derived from the first.  */
    5679                 :            : #define COMPARE_DERIVED       2 /* Like COMPARE_BASE, but in
    5680                 :            :                                    reverse.  */
    5681                 :            : #define COMPARE_REDECLARATION 4 /* The comparison is being done when
    5682                 :            :                                    another declaration of an existing
    5683                 :            :                                    entity is seen.  */
    5684                 :            : #define COMPARE_STRUCTURAL    8 /* The comparison is intended to be
    5685                 :            :                                    structural. The actual comparison
    5686                 :            :                                    will be identical to
    5687                 :            :                                    COMPARE_STRICT.  */
    5688                 :            : 
    5689                 :            : /* Used with start function.  */
    5690                 :            : #define SF_DEFAULT           0  /* No flags.  */
    5691                 :            : #define SF_PRE_PARSED        1  /* The function declaration has
    5692                 :            :                                    already been parsed.  */
    5693                 :            : #define SF_INCLASS_INLINE    2  /* The function is an inline, defined
    5694                 :            :                                    in the class body.  */
    5695                 :            : 
    5696                 :            : /* Used with start_decl's initialized parameter.  */
    5697                 :            : #define SD_UNINITIALIZED     0
    5698                 :            : #define SD_INITIALIZED       1
    5699                 :            : #define SD_DEFAULTED         2
    5700                 :            : #define SD_DELETED           3
    5701                 :            : 
    5702                 :            : /* Returns nonzero iff TYPE1 and TYPE2 are the same type, or if TYPE2
    5703                 :            :    is derived from TYPE1, or if TYPE2 is a pointer (reference) to a
    5704                 :            :    class derived from the type pointed to (referred to) by TYPE1.  */
    5705                 :            : #define same_or_base_type_p(TYPE1, TYPE2) \
    5706                 :            :   comptypes ((TYPE1), (TYPE2), COMPARE_BASE)
    5707                 :            : 
    5708                 :            : /* These macros are used to access a TEMPLATE_PARM_INDEX.  */
    5709                 :            : #define TEMPLATE_PARM_INDEX_CAST(NODE) \
    5710                 :            :         ((template_parm_index*)TEMPLATE_PARM_INDEX_CHECK (NODE))
    5711                 :            : #define TEMPLATE_PARM_IDX(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->index)
    5712                 :            : #define TEMPLATE_PARM_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->level)
    5713                 :            : #define TEMPLATE_PARM_DESCENDANTS(NODE) (TREE_CHAIN (NODE))
    5714                 :            : #define TEMPLATE_PARM_ORIG_LEVEL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->orig_level)
    5715                 :            : #define TEMPLATE_PARM_DECL(NODE) (TEMPLATE_PARM_INDEX_CAST (NODE)->decl)
    5716                 :            : #define TEMPLATE_PARM_PARAMETER_PACK(NODE) \
    5717                 :            :   (TREE_LANG_FLAG_0 (TEMPLATE_PARM_INDEX_CHECK (NODE)))
    5718                 :            : 
    5719                 :            : /* These macros are for accessing the fields of TEMPLATE_TYPE_PARM,
    5720                 :            :    TEMPLATE_TEMPLATE_PARM and BOUND_TEMPLATE_TEMPLATE_PARM nodes.  */
    5721                 :            : #define TEMPLATE_TYPE_PARM_INDEX(NODE)                                  \
    5722                 :            :   (TYPE_VALUES_RAW (TREE_CHECK3 ((NODE), TEMPLATE_TYPE_PARM,            \
    5723                 :            :                                  TEMPLATE_TEMPLATE_PARM,                \
    5724                 :            :                                  BOUND_TEMPLATE_TEMPLATE_PARM)))
    5725                 :            : #define TEMPLATE_TYPE_IDX(NODE) \
    5726                 :            :   (TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (NODE)))
    5727                 :            : #define TEMPLATE_TYPE_LEVEL(NODE) \
    5728                 :            :   (TEMPLATE_PARM_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
    5729                 :            : #define TEMPLATE_TYPE_ORIG_LEVEL(NODE) \
    5730                 :            :   (TEMPLATE_PARM_ORIG_LEVEL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
    5731                 :            : #define TEMPLATE_TYPE_DECL(NODE) \
    5732                 :            :   (TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (NODE)))
    5733                 :            : #define TEMPLATE_TYPE_PARAMETER_PACK(NODE) \
    5734                 :            :   (TEMPLATE_PARM_PARAMETER_PACK (TEMPLATE_TYPE_PARM_INDEX (NODE)))
    5735                 :            : 
    5736                 :            : /* For a C++17 class deduction placeholder, the template it represents.  */
    5737                 :            : #define CLASS_PLACEHOLDER_TEMPLATE(NODE) \
    5738                 :            :   (DECL_INITIAL (TYPE_NAME (TEMPLATE_TYPE_PARM_CHECK (NODE))))
    5739                 :            : 
    5740                 :            : /* Contexts in which auto deduction occurs. These flags are
    5741                 :            :    used to control diagnostics in do_auto_deduction.  */
    5742                 :            : 
    5743                 :            : enum auto_deduction_context
    5744                 :            : {
    5745                 :            :   adc_unspecified,   /* Not given */
    5746                 :            :   adc_variable_type, /* Variable initializer deduction */
    5747                 :            :   adc_return_type,   /* Return type deduction */
    5748                 :            :   adc_unify,         /* Template argument deduction */
    5749                 :            :   adc_requirement,   /* Argument deduction constraint */
    5750                 :            :   adc_decomp_type    /* Decomposition declaration initializer deduction */
    5751                 :            : };
    5752                 :            : 
    5753                 :            : /* True if this type-parameter belongs to a class template, used by C++17
    5754                 :            :    class template argument deduction.  */
    5755                 :            : #define TEMPLATE_TYPE_PARM_FOR_CLASS(NODE) \
    5756                 :            :   (TREE_LANG_FLAG_0 (TEMPLATE_TYPE_PARM_CHECK (NODE)))
    5757                 :            : 
    5758                 :            : /* True iff this TEMPLATE_TYPE_PARM represents decltype(auto).  */
    5759                 :            : #define AUTO_IS_DECLTYPE(NODE) \
    5760                 :            :   (TYPE_LANG_FLAG_5 (TEMPLATE_TYPE_PARM_CHECK (NODE)))
    5761                 :            : 
    5762                 :            : /* These constants can used as bit flags in the process of tree formatting.
    5763                 :            : 
    5764                 :            :    TFF_PLAIN_IDENTIFIER: unqualified part of a name.
    5765                 :            :    TFF_SCOPE: include the class and namespace scope of the name.
    5766                 :            :    TFF_CHASE_TYPEDEF: print the original type-id instead of the typedef-name.
    5767                 :            :    TFF_DECL_SPECIFIERS: print decl-specifiers.
    5768                 :            :    TFF_CLASS_KEY_OR_ENUM: precede a class-type name (resp. enum name) with
    5769                 :            :        a class-key (resp. `enum').
    5770                 :            :    TFF_RETURN_TYPE: include function return type.
    5771                 :            :    TFF_FUNCTION_DEFAULT_ARGUMENTS: include function default parameter values.
    5772                 :            :    TFF_EXCEPTION_SPECIFICATION: show function exception specification.
    5773                 :            :    TFF_TEMPLATE_HEADER: show the template<...> header in a
    5774                 :            :        template-declaration.
    5775                 :            :    TFF_TEMPLATE_NAME: show only template-name.
    5776                 :            :    TFF_EXPR_IN_PARENS: parenthesize expressions.
    5777                 :            :    TFF_NO_FUNCTION_ARGUMENTS: don't show function arguments.
    5778                 :            :    TFF_UNQUALIFIED_NAME: do not print the qualifying scope of the
    5779                 :            :        top-level entity.
    5780                 :            :    TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS: do not omit template arguments
    5781                 :            :        identical to their defaults.
    5782                 :            :    TFF_NO_TEMPLATE_BINDINGS: do not print information about the template
    5783                 :            :        arguments for a function template specialization.
    5784                 :            :    TFF_POINTER: we are printing a pointer type.  */
    5785                 :            : 
    5786                 :            : #define TFF_PLAIN_IDENTIFIER                    (0)
    5787                 :            : #define TFF_SCOPE                               (1)
    5788                 :            : #define TFF_CHASE_TYPEDEF                       (1 << 1)
    5789                 :            : #define TFF_DECL_SPECIFIERS                     (1 << 2)
    5790                 :            : #define TFF_CLASS_KEY_OR_ENUM                   (1 << 3)
    5791                 :            : #define TFF_RETURN_TYPE                         (1 << 4)
    5792                 :            : #define TFF_FUNCTION_DEFAULT_ARGUMENTS          (1 << 5)
    5793                 :            : #define TFF_EXCEPTION_SPECIFICATION             (1 << 6)
    5794                 :            : #define TFF_TEMPLATE_HEADER                     (1 << 7)
    5795                 :            : #define TFF_TEMPLATE_NAME                       (1 << 8)
    5796                 :            : #define TFF_EXPR_IN_PARENS                      (1 << 9)
    5797                 :            : #define TFF_NO_FUNCTION_ARGUMENTS               (1 << 10)
    5798                 :            : #define TFF_UNQUALIFIED_NAME                    (1 << 11)
    5799                 :            : #define TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS  (1 << 12)
    5800                 :            : #define TFF_NO_TEMPLATE_BINDINGS                (1 << 13)
    5801                 :            : #define TFF_POINTER                             (1 << 14)
    5802                 :            : 
    5803                 :            : /* These constants can be used as bit flags to control strip_typedefs.
    5804                 :            : 
    5805                 :            :    STF_USER_VISIBLE: use heuristics to try to avoid stripping user-facing
    5806                 :            :        aliases of internal details.  This is intended for diagnostics,
    5807                 :            :        where it should (for example) give more useful "aka" types.
    5808                 :            : 
    5809                 :            :    STF_STRIP_DEPENDENT: allow the stripping of aliases with dependent
    5810                 :            :        template parameters, relying on code elsewhere to report any
    5811                 :            :        appropriate diagnostics.  */
    5812                 :            : const unsigned int STF_USER_VISIBLE = 1U;
    5813                 :            : const unsigned int STF_STRIP_DEPENDENT = 1U << 1;
    5814                 :            : 
    5815                 :            : /* Returns the TEMPLATE_DECL associated to a TEMPLATE_TEMPLATE_PARM
    5816                 :            :    node.  */
    5817                 :            : #define TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL(NODE)      \
    5818                 :            :   ((TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM)   \
    5819                 :            :    ? TYPE_TI_TEMPLATE (NODE)                            \
    5820                 :            :    : TYPE_NAME (NODE))
    5821                 :            : 
    5822                 :            : /* in lex.c  */
    5823                 :            : 
    5824                 :            : extern void init_reswords (void);
    5825                 :            : 
    5826                 :            : /* Various flags for the overloaded operator information.  */
    5827                 :            : enum ovl_op_flags
    5828                 :            :   {
    5829                 :            :     OVL_OP_FLAG_NONE = 0,       /* Don't care.  */
    5830                 :            :     OVL_OP_FLAG_UNARY = 1,      /* Is unary.  */
    5831                 :            :     OVL_OP_FLAG_BINARY = 2,     /* Is binary.  */
    5832                 :            :     OVL_OP_FLAG_AMBIARY = 3,    /* May be unary or binary.  */
    5833                 :            :     OVL_OP_FLAG_ALLOC = 4,      /* operator new or delete.  */
    5834                 :            :     OVL_OP_FLAG_DELETE = 1,     /* operator delete.  */
    5835                 :            :     OVL_OP_FLAG_VEC = 2         /* vector new or delete.  */
    5836                 :            :   };
    5837                 :            : 
    5838                 :            : /* Compressed operator codes.  Order is determined by operators.def
    5839                 :            :    and does not match that of tree_codes.  */
    5840                 :            : enum ovl_op_code
    5841                 :            :   {
    5842                 :            :     OVL_OP_ERROR_MARK,
    5843                 :            :     OVL_OP_NOP_EXPR,
    5844                 :            : #define DEF_OPERATOR(NAME, CODE, MANGLING, FLAGS) OVL_OP_##CODE,
    5845                 :            : #define DEF_ASSN_OPERATOR(NAME, CODE, MANGLING) /* NOTHING */
    5846                 :            : #include "operators.def"
    5847                 :            :     OVL_OP_MAX
    5848                 :            :   };
    5849                 :            : 
    5850                 :            : struct GTY(()) ovl_op_info_t {
    5851                 :            :   /* The IDENTIFIER_NODE for the operator.  */
    5852                 :            :   tree identifier;
    5853                 :            :   /* The name of the operator.  */
    5854                 :            :   const char *name;
    5855                 :            :   /* The mangled name of the operator.  */
    5856                 :            :   const char *mangled_name;
    5857                 :            :   /* The (regular) tree code.  */
    5858                 :            :   enum tree_code tree_code : 16;
    5859                 :            :   /* The (compressed) operator code.  */
    5860                 :            :   enum ovl_op_code ovl_op_code : 8;
    5861                 :            :   /* The ovl_op_flags of the operator */
    5862                 :            :   unsigned flags : 8;
    5863                 :            : };
    5864                 :            : 
    5865                 :            : /* Overloaded operator info indexed by ass_op_p & ovl_op_code.  */
    5866                 :            : extern GTY(()) ovl_op_info_t ovl_op_info[2][OVL_OP_MAX];
    5867                 :            : /* Mapping from tree_codes to ovl_op_codes.  */
    5868                 :            : extern GTY(()) unsigned char ovl_op_mapping[MAX_TREE_CODES];
    5869                 :            : /* Mapping for ambi-ary operators from the binary to the unary.  */
    5870                 :            : extern GTY(()) unsigned char ovl_op_alternate[OVL_OP_MAX];
    5871                 :            : 
    5872                 :            : /* Given an ass_op_p boolean and a tree code, return a pointer to its
    5873                 :            :    overloaded operator info.  Tree codes for non-overloaded operators
    5874                 :            :    map to the error-operator.  */
    5875                 :            : #define OVL_OP_INFO(IS_ASS_P, TREE_CODE)                        \
    5876                 :            :   (&ovl_op_info[(IS_ASS_P) != 0][ovl_op_mapping[(TREE_CODE)]])
    5877                 :            : /* Overloaded operator info for an identifier for which
    5878                 :            :    IDENTIFIER_OVL_OP_P is true.  */
    5879                 :            : #define IDENTIFIER_OVL_OP_INFO(NODE) \
    5880                 :            :   (&ovl_op_info[IDENTIFIER_KIND_BIT_0 (NODE)][IDENTIFIER_CP_INDEX (NODE)])
    5881                 :            : #define IDENTIFIER_OVL_OP_FLAGS(NODE) \
    5882                 :            :   (IDENTIFIER_OVL_OP_INFO (NODE)->flags)
    5883                 :            : 
    5884                 :   41643503 : inline tree ovl_op_identifier (bool isass, tree_code code)
    5885                 :   18401373 : { return OVL_OP_INFO(isass, code)->identifier; }
    5886                 :   23240100 : inline tree ovl_op_identifier (tree_code code) { return ovl_op_identifier (false, code); }
    5887                 :            : #define assign_op_identifier (ovl_op_info[true][OVL_OP_NOP_EXPR].identifier)
    5888                 :            : #define call_op_identifier (ovl_op_info[false][OVL_OP_CALL_EXPR].identifier)
    5889                 :            : 
    5890                 :            : /* A type-qualifier, or bitmask therefore, using the TYPE_QUAL
    5891                 :            :    constants.  */
    5892                 :            : 
    5893                 :            : typedef int cp_cv_quals;
    5894                 :            : 
    5895                 :            : /* Non-static member functions have an optional virt-specifier-seq.
    5896                 :            :    There is a VIRT_SPEC value for each virt-specifier.
    5897                 :            :    They can be combined by bitwise-or to form the complete set of
    5898                 :            :    virt-specifiers for a member function.  */
    5899                 :            : enum virt_specifier
    5900                 :            :   {
    5901                 :            :     VIRT_SPEC_UNSPECIFIED = 0x0,
    5902                 :            :     VIRT_SPEC_FINAL       = 0x1,
    5903                 :            :     VIRT_SPEC_OVERRIDE    = 0x2
    5904                 :            :   };
    5905                 :            : 
    5906                 :            : /* A type-qualifier, or bitmask therefore, using the VIRT_SPEC
    5907                 :            :    constants.  */
    5908                 :            : 
    5909                 :            : typedef int cp_virt_specifiers;
    5910                 :            : 
    5911                 :            : /* Wherever there is a function-cv-qual, there could also be a ref-qualifier:
    5912                 :            : 
    5913                 :            :    [dcl.fct]
    5914                 :            :    The return type, the parameter-type-list, the ref-qualifier, and
    5915                 :            :    the cv-qualifier-seq, but not the default arguments or the exception
    5916                 :            :    specification, are part of the function type.
    5917                 :            : 
    5918                 :            :    REF_QUAL_NONE    Ordinary member function with no ref-qualifier
    5919                 :            :    REF_QUAL_LVALUE  Member function with the &-ref-qualifier
    5920                 :            :    REF_QUAL_RVALUE  Member function with the &&-ref-qualifier */
    5921                 :            : 
    5922                 :            : enum cp_ref_qualifier {
    5923                 :            :   REF_QUAL_NONE = 0,
    5924                 :            :   REF_QUAL_LVALUE = 1,
    5925                 :            :   REF_QUAL_RVALUE = 2
    5926                 :            : };
    5927                 :            : 
    5928                 :            : /* A storage class.  */
    5929                 :            : 
    5930                 :            : enum cp_storage_class {
    5931                 :            :   /* sc_none must be zero so that zeroing a cp_decl_specifier_seq
    5932                 :            :      sets the storage_class field to sc_none.  */
    5933                 :            :   sc_none = 0,
    5934                 :            :   sc_auto,
    5935                 :            :   sc_register,
    5936                 :            :   sc_static,
    5937                 :            :   sc_extern,
    5938                 :            :   sc_mutable
    5939                 :            : };
    5940                 :            : 
    5941                 :            : /* An individual decl-specifier.  This is used to index the array of
    5942                 :            :    locations for the declspecs in struct cp_decl_specifier_seq
    5943                 :            :    below.  */
    5944                 :            : 
    5945                 :            : enum cp_decl_spec {
    5946                 :            :   ds_first,
    5947                 :            :   ds_signed = ds_first,
    5948                 :            :   ds_unsigned,
    5949                 :            :   ds_short,
    5950                 :            :   ds_long,
    5951                 :            :   ds_const,
    5952                 :            :   ds_volatile,
    5953                 :            :   ds_restrict,
    5954                 :            :   ds_inline,
    5955                 :            :   ds_virtual,
    5956                 :            :   ds_explicit,
    5957                 :            :   ds_friend,
    5958                 :            :   ds_typedef,
    5959                 :            :   ds_alias,
    5960                 :            :   ds_constexpr,
    5961                 :            :   ds_complex,
    5962                 :            :   ds_constinit,
    5963                 :            :   ds_consteval,
    5964                 :            :   ds_thread,
    5965                 :            :   ds_type_spec,
    5966                 :            :   ds_redefined_builtin_type_spec,
    5967                 :            :   ds_attribute,
    5968                 :            :   ds_std_attribute,
    5969                 :            :   ds_storage_class,
    5970                 :            :   ds_long_long,
    5971                 :            :   ds_concept,
    5972                 :            :   ds_last /* This enumerator must always be the last one.  */
    5973                 :            : };
    5974                 :            : 
    5975                 :            : /* A decl-specifier-seq.  */
    5976                 :            : 
    5977                 :            : struct cp_decl_specifier_seq {
    5978                 :            :   /* An array of locations for the declaration sepecifiers, indexed by
    5979                 :            :      enum cp_decl_spec_word.  */
    5980                 :            :   location_t locations[ds_last];
    5981                 :            :   /* The primary type, if any, given by the decl-specifier-seq.
    5982                 :            :      Modifiers, like "short", "const", and "unsigned" are not
    5983                 :            :      reflected here.  This field will be a TYPE, unless a typedef-name
    5984                 :            :      was used, in which case it will be a TYPE_DECL.  */
    5985                 :            :   tree type;
    5986                 :            :   /* The attributes, if any, provided with the specifier sequence.  */
    5987                 :            :   tree attributes;
    5988                 :            :   /* The c++11 attributes that follows the type specifier.  */
    5989                 :            :   tree std_attributes;
    5990                 :            :   /* If non-NULL, a built-in type that the user attempted to redefine
    5991                 :            :      to some other type.  */
    5992                 :            :   tree redefined_builtin_type;
    5993                 :            :   /* The explicit-specifier, if any.  */
    5994                 :            :   tree explicit_specifier;
    5995                 :            :   /* The storage class specified -- or sc_none if no storage class was
    5996                 :            :      explicitly specified.  */
    5997                 :            :   cp_storage_class storage_class;
    5998                 :            :   /* For the __intN declspec, this stores the index into the int_n_* arrays.  */
    5999                 :            :   int int_n_idx;
    6000                 :            :   /* True iff TYPE_SPEC defines a class or enum.  */
    6001                 :            :   BOOL_BITFIELD type_definition_p : 1;
    6002                 :            :   /* True iff multiple types were (erroneously) specified for this
    6003                 :            :      decl-specifier-seq.  */
    6004                 :            :   BOOL_BITFIELD multiple_types_p : 1;
    6005                 :            :   /* True iff multiple storage classes were (erroneously) specified
    6006                 :            :      for this decl-specifier-seq or a combination of a storage class
    6007                 :            :      with a typedef specifier.  */
    6008                 :            :   BOOL_BITFIELD conflicting_specifiers_p : 1;
    6009                 :            :   /* True iff at least one decl-specifier was found.  */
    6010                 :            :   BOOL_BITFIELD any_specifiers_p : 1;
    6011                 :            :   /* True iff at least one type-specifier was found.  */
    6012                 :            :   BOOL_BITFIELD any_type_specifiers_p : 1;
    6013                 :            :   /* True iff "int" was explicitly provided.  */
    6014                 :            :   BOOL_BITFIELD explicit_int_p : 1;
    6015                 :            :   /* True iff "__intN" was explicitly provided.  */
    6016                 :            :   BOOL_BITFIELD explicit_intN_p : 1;
    6017                 :            :   /* True iff "char" was explicitly provided.  */
    6018                 :            :   BOOL_BITFIELD explicit_char_p : 1;
    6019                 :            :   /* True iff ds_thread is set for __thread, not thread_local.  */
    6020                 :            :   BOOL_BITFIELD gnu_thread_keyword_p : 1;
    6021                 :            :   /* True iff the type is a decltype.  */
    6022                 :            :   BOOL_BITFIELD decltype_p : 1;
    6023                 :            :   /* True iff the alternate "__intN__" form of the __intN type has been
    6024                 :            :      used.  */
    6025                 :            :   BOOL_BITFIELD int_n_alt: 1;
    6026                 :            : };
    6027                 :            : 
    6028                 :            : /* The various kinds of declarators.  */
    6029                 :            : 
    6030                 :            : enum cp_declarator_kind {
    6031                 :            :   cdk_id,
    6032                 :            :   cdk_function,
    6033                 :            :   cdk_array,
    6034                 :            :   cdk_pointer,
    6035                 :            :   cdk_reference,
    6036                 :            :   cdk_ptrmem,
    6037                 :            :   cdk_decomp,
    6038                 :            :   cdk_error
    6039                 :            : };
    6040                 :            : 
    6041                 :            : /* A declarator.  */
    6042                 :            : 
    6043                 :            : typedef struct cp_declarator cp_declarator;
    6044                 :            : 
    6045                 :            : typedef struct cp_parameter_declarator cp_parameter_declarator;
    6046                 :            : 
    6047                 :            : /* A parameter, before it has been semantically analyzed.  */
    6048                 :            : struct cp_parameter_declarator {
    6049                 :            :   /* The next parameter, or NULL_TREE if none.  */
    6050                 :            :   cp_parameter_declarator *next;
    6051                 :            :   /* The decl-specifiers-seq for the parameter.  */
    6052                 :            :   cp_decl_specifier_seq decl_specifiers;
    6053                 :            :   /* The declarator for the parameter.  */
    6054                 :            :   cp_declarator *declarator;
    6055                 :            :   /* The default-argument expression, or NULL_TREE, if none.  */
    6056                 :            :   tree default_argument;
    6057                 :            :   /* True iff this is a template parameter pack.  */
    6058                 :            :   bool template_parameter_pack_p;
    6059                 :            :   /* Location within source.  */
    6060                 :            :   location_t loc;
    6061                 :            : };
    6062                 :            : 
    6063                 :            : /* A declarator.  */
    6064                 :            : struct cp_declarator {
    6065                 :            :   /* The kind of declarator.  */
    6066                 :            :   ENUM_BITFIELD (cp_declarator_kind) kind : 4;
    6067                 :            :   /* Whether we parsed an ellipsis (`...') just before the declarator,
    6068                 :            :      to indicate this is a parameter pack.  */
    6069                 :            :   BOOL_BITFIELD parameter_pack_p : 1;
    6070                 :            :   /* If this declarator is parenthesized, this the open-paren.  It is
    6071                 :            :      UNKNOWN_LOCATION when not parenthesized.  */
    6072                 :            :   location_t parenthesized;
    6073                 :            : 
    6074                 :            :   location_t id_loc; /* Currently only set for cdk_id, cdk_decomp and
    6075                 :            :                         cdk_function. */
    6076                 :            :   /* GNU Attributes that apply to this declarator.  If the declarator
    6077                 :            :      is a pointer or a reference, these attribute apply to the type
    6078                 :            :      pointed to.  */
    6079                 :            :   tree attributes;
    6080                 :            :   /* Standard C++11 attributes that apply to this declarator.  If the
    6081                 :            :      declarator is a pointer or a reference, these attributes apply
    6082                 :            :      to the pointer, rather than to the type pointed to.  */
    6083                 :            :   tree std_attributes;
    6084                 :            :   /* For all but cdk_id, cdk_decomp and cdk_error, the contained declarator.
    6085                 :            :      For cdk_id, cdk_decomp and cdk_error, guaranteed to be NULL.  */
    6086                 :            :   cp_declarator *declarator;
    6087                 :            :   union {
    6088                 :            :     /* For identifiers.  */
    6089                 :            :     struct {
    6090                 :            :       /* If non-NULL, the qualifying scope (a NAMESPACE_DECL or
    6091                 :            :          *_TYPE) for this identifier.  */
    6092                 :            :       tree qualifying_scope;
    6093                 :            :       /* The unqualified name of the entity -- an IDENTIFIER_NODE,
    6094                 :            :          BIT_NOT_EXPR, or TEMPLATE_ID_EXPR.  */
    6095                 :            :       tree unqualified_name;
    6096                 :            :       /* If this is the name of a function, what kind of special
    6097                 :            :          function (if any).  */
    6098                 :            :       special_function_kind sfk;
    6099                 :            :     } id;
    6100                 :            :     /* For functions.  */
    6101                 :            :     struct {
    6102                 :            :       /* The parameters to the function as a TREE_LIST of decl/default.  */
    6103                 :            :       tree parameters;
    6104                 :            :       /* The cv-qualifiers for the function.  */
    6105                 :            :       cp_cv_quals qualifiers;
    6106                 :            :       /* The virt-specifiers for the function.  */
    6107                 :            :       cp_virt_specifiers virt_specifiers;
    6108                 :            :       /* The ref-qualifier for the function.  */
    6109                 :            :       cp_ref_qualifier ref_qualifier;
    6110                 :            :       /* The transaction-safety qualifier for the function.  */
    6111                 :            :       tree tx_qualifier;
    6112                 :            :       /* The exception-specification for the function.  */
    6113                 :            :       tree exception_specification;
    6114                 :            :       /* The late-specified return type, if any.  */
    6115                 :            :       tree late_return_type;
    6116                 :            :       /* The trailing requires-clause, if any. */
    6117                 :            :       tree requires_clause;
    6118                 :            :     } function;
    6119                 :            :     /* For arrays.  */
    6120                 :            :     struct {
    6121                 :            :       /* The bounds to the array.  */
    6122                 :            :       tree bounds;
    6123                 :            :     } array;
    6124                 :            :     /* For cdk_pointer and cdk_ptrmem.  */
    6125                 :            :     struct {
    6126                 :            :       /* The cv-qualifiers for the pointer.  */
    6127                 :            :       cp_cv_quals qualifiers;
    6128                 :            :       /* For cdk_ptrmem, the class type containing the member.  */
    6129                 :            :       tree class_type;
    6130                 :            :     } pointer;
    6131                 :            :     /* For cdk_reference */
    6132                 :            :     struct {
    6133                 :            :       /* The cv-qualifiers for the reference.  These qualifiers are
    6134                 :            :          only used to diagnose ill-formed code.  */
    6135                 :            :       cp_cv_quals qualifiers;
    6136                 :            :       /* Whether this is an rvalue reference */
    6137                 :            :       bool rvalue_ref;
    6138                 :            :     } reference;
    6139                 :            :   } u;
    6140                 :            : };
    6141                 :            : 
    6142                 :            : /* A level of template instantiation.  */
    6143                 :            : struct GTY((chain_next ("%h.next"))) tinst_level {
    6144                 :            :   /* The immediately deeper level in the chain.  */
    6145                 :            :   struct tinst_level *next;
    6146                 :            : 
    6147                 :            :   /* The original node.  TLDCL can be a DECL (for a function or static
    6148                 :            :      data member), a TYPE (for a class), depending on what we were
    6149                 :            :      asked to instantiate, or a TREE_LIST with the template as PURPOSE
    6150                 :            :      and the template args as VALUE, if we are substituting for
    6151                 :            :      overload resolution.  In all these cases, TARGS is NULL.
    6152                 :            :      However, to avoid creating TREE_LIST objects for substitutions if
    6153                 :            :      we can help, we store PURPOSE and VALUE in TLDCL and TARGS,
    6154                 :            :      respectively.  So TLDCL stands for TREE_LIST or DECL (the
    6155                 :            :      template is a DECL too), whereas TARGS stands for the template
    6156                 :            :      arguments.  */
    6157                 :            :   tree tldcl, targs;
    6158                 :            : 
    6159                 :            :  private:
    6160                 :            :   /* Return TRUE iff the original node is a split list.  */
    6161                 :    3299404 :   bool split_list_p () const { return targs; }
    6162                 :            : 
    6163                 :            :   /* Return TRUE iff the original node is a TREE_LIST object.  */
    6164                 :  128395406 :   bool tree_list_p () const
    6165                 :            :   {
    6166                 :  128395406 :     return !split_list_p () && TREE_CODE (tldcl) == TREE_LIST;
    6167                 :            :   }
    6168                 :            : 
    6169                 :            :   /* Return TRUE iff the original node is not a list, split or not.  */
    6170                 :       4540 :   bool not_list_p () const
    6171                 :            :   {
    6172                 :       9080 :     return !split_list_p () && !tree_list_p ();
    6173                 :            :   }
    6174                 :            : 
    6175                 :            :   /* Convert (in place) the original node from a split list to a
    6176                 :            :      TREE_LIST.  */
    6177                 :            :   tree to_list ();
    6178                 :            : 
    6179                 :            :  public:
    6180                 :            :   /* Release storage for OBJ and node, if it's a TREE_LIST.  */
    6181                 :            :   static void free (tinst_level *obj);
    6182                 :            : 
    6183                 :            :   /* Return TRUE iff the original node is a list, split or not.  */
    6184                 :       8946 :   bool list_p () const { return !not_list_p (); }
    6185                 :            : 
    6186                 :            :   /* Return the original node; if it's a split list, make it a
    6187                 :            :      TREE_LIST first, so that it can be returned as a single tree
    6188                 :            :      object.  */
    6189                 :       4663 :   tree get_node () {
    6190                 :       4663 :     if (!split_list_p ()) return tldcl;
    6191                 :        418 :     else return to_list ();
    6192                 :            :   }
    6193                 :            : 
    6194                 :            :   /* Return the original node if it's a DECL or a TREE_LIST, but do
    6195                 :            :      NOT convert a split list to a TREE_LIST: return NULL instead.  */
    6196                 :   18105000 :   tree maybe_get_node () const {
    6197                 :   18105000 :     if (!split_list_p ()) return tldcl;
    6198                 :            :     else return NULL_TREE;
    6199                 :            :   }
    6200                 :            : 
    6201                 :            :   /* The location where the template is instantiated.  */
    6202                 :            :   location_t locus;
    6203                 :            : 
    6204                 :            :   /* errorcount + sorrycount when we pushed this level.  */
    6205                 :            :   unsigned short errors;
    6206                 :            : 
    6207                 :            :   /* Count references to this object.  If refcount reaches
    6208                 :            :      refcount_infinity value, we don't increment or decrement the
    6209                 :            :      refcount anymore, as the refcount isn't accurate anymore.
    6210                 :            :      The object can be still garbage collected if unreferenced from
    6211                 :            :      anywhere, which might keep referenced objects referenced longer than
    6212                 :            :      otherwise necessary.  Hitting the infinity is rare though.  */
    6213                 :            :   unsigned short refcount;
    6214                 :            : 
    6215                 :            :   /* Infinity value for the above refcount.  */
    6216                 :            :   static const unsigned short refcount_infinity = (unsigned short) ~0;
    6217                 :            : };
    6218                 :            : 
    6219                 :            : /* BUILT_IN_FRONTEND function codes.  */
    6220                 :            : enum cp_built_in_function {
    6221                 :            :   CP_BUILT_IN_IS_CONSTANT_EVALUATED,
    6222                 :            :   CP_BUILT_IN_INTEGER_PACK,
    6223                 :            :   CP_BUILT_IN_SOURCE_LOCATION,
    6224                 :            :   CP_BUILT_IN_LAST
    6225                 :            : };
    6226                 :            : 
    6227                 :            : bool decl_spec_seq_has_spec_p (const cp_decl_specifier_seq *, cp_decl_spec);
    6228                 :            : 
    6229                 :            : /* Return the type of the `this' parameter of FNTYPE.  */
    6230                 :            : 
    6231                 :            : inline tree
    6232                 :   83135557 : type_of_this_parm (const_tree fntype)
    6233                 :            : {
    6234                 :   83135557 :   function_args_iterator iter;
    6235                 :   83135557 :   gcc_assert (TREE_CODE (fntype) == METHOD_TYPE);
    6236                 :   83135557 :   function_args_iter_init (&iter, fntype);
    6237                 :   83135557 :   return function_args_iter_cond (&iter);
    6238                 :            : }
    6239                 :            : 
    6240                 :            : /* Return the class of the `this' parameter of FNTYPE.  */
    6241                 :            : 
    6242                 :            : inline tree
    6243                 :   73850637 : class_of_this_parm (const_tree fntype)
    6244                 :            : {
    6245                 :   73850637 :   return TREE_TYPE (type_of_this_parm (fntype));
    6246                 :            : }
    6247                 :            : 
    6248                 :            : /* A parameter list indicating for a function with no parameters,
    6249                 :            :    e.g  "int f(void)".  */
    6250                 :            : extern cp_parameter_declarator *no_parameters;
    6251                 :            : 
    6252                 :            : /* Various dump ids.  */
    6253                 :            : extern int class_dump_id;
    6254                 :            : extern int raw_dump_id;
    6255                 :            : 
    6256                 :            : /* in call.c */
    6257                 :            : extern bool check_dtor_name                     (tree, tree);
    6258                 :            : int magic_varargs_p                             (tree);
    6259                 :            : 
    6260                 :            : extern tree build_conditional_expr              (const op_location_t &,
    6261                 :            :                                                  tree, tree, tree,
    6262                 :            :                                                  tsubst_flags_t);
    6263                 :            : extern tree build_addr_func                     (tree, tsubst_flags_t);
    6264                 :            : extern void set_flags_from_callee               (tree);
    6265                 :            : extern tree build_call_a                        (tree, int, tree*);
    6266                 :            : extern tree build_call_n                        (tree, int, ...);
    6267                 :            : extern bool null_ptr_cst_p                      (tree);
    6268                 :            : extern bool null_member_pointer_value_p         (tree);
    6269                 :            : extern bool sufficient_parms_p                  (const_tree);
    6270                 :            : extern tree type_decays_to                      (tree);
    6271                 :            : extern tree extract_call_expr                   (tree);
    6272                 :            : extern tree build_trivial_dtor_call             (tree);
    6273                 :            : extern tree build_user_type_conversion          (tree, tree, int,
    6274                 :            :                                                  tsubst_flags_t);
    6275                 :            : extern tree build_new_function_call             (tree, vec<tree, va_gc> **,
    6276                 :            :                                                  tsubst_flags_t);
    6277                 :            : extern tree build_operator_new_call             (tree, vec<tree, va_gc> **,
    6278                 :            :                                                  tree *, tree *, tree, tree,
    6279                 :            :                                                  tree *, tsubst_flags_t);
    6280                 :            : extern tree build_new_method_call               (tree, tree,
    6281                 :            :                                                  vec<tree, va_gc> **, tree,
    6282                 :            :                                                  int, tree *, tsubst_flags_t);
    6283                 :            : extern tree build_special_member_call           (tree, tree,
    6284                 :            :                                                  vec<tree, va_gc> **,
    6285                 :            :                                                  tree, int, tsubst_flags_t);
    6286                 :            : extern tree build_new_op                        (const op_location_t &,
    6287                 :            :                                                  enum tree_code,
    6288                 :            :                                                  int, tree, tree, tree, tree *,
    6289                 :            :                                                  tsubst_flags_t);
    6290                 :            : extern tree build_op_call                       (tree, vec<tree, va_gc> **,
    6291                 :            :                                                  tsubst_flags_t);
    6292                 :            : extern bool aligned_allocation_fn_p             (tree);
    6293                 :            : extern tree destroying_delete_p                 (tree);
    6294                 :            : extern bool usual_deallocation_fn_p             (tree);
    6295                 :            : extern tree build_op_delete_call                (enum tree_code, tree, tree,
    6296                 :            :                                                  bool, tree, tree,
    6297                 :            :                                                  tsubst_flags_t);
    6298                 :            : extern bool can_convert                         (tree, tree, tsubst_flags_t);
    6299                 :            : extern bool can_convert_standard                (tree, tree, tsubst_flags_t);
    6300                 :            : extern bool can_convert_arg                     (tree, tree, tree, int,
    6301                 :            :                                                  tsubst_flags_t);
    6302                 :            : extern bool can_convert_arg_bad                 (tree, tree, tree, int,
    6303                 :            :                                                  tsubst_flags_t);
    6304                 :            : extern int conv_flags                           (int, int, tree, tree, int);
    6305                 :            : extern struct conversion * good_conversion      (tree, tree, tree, int, tsubst_flags_t);
    6306                 :            : extern location_t get_fndecl_argument_location  (tree, int);
    6307                 :            : extern void complain_about_bad_argument (location_t arg_loc,
    6308                 :            :                                                  tree from_type, tree to_type,
    6309                 :            :                                                  tree fndecl, int parmnum);
    6310                 :            : extern void maybe_inform_about_fndecl_for_bogus_argument_init (tree, int);
    6311                 :            : 
    6312                 :            : 
    6313                 :            : /* A class for recording information about access failures (e.g. private
    6314                 :            :    fields), so that we can potentially supply a fix-it hint about
    6315                 :            :    an accessor (from a context in which the constness of the object
    6316                 :            :    is known).  */
    6317                 :            : 
    6318                 :            : class access_failure_info
    6319                 :            : {
    6320                 :            :  public:
    6321                 :    7199550 :   access_failure_info () : m_was_inaccessible (false),
    6322                 :            :     m_basetype_path (NULL_TREE),
    6323                 :    7199550 :     m_decl (NULL_TREE), m_diag_decl (NULL_TREE) {}
    6324                 :            : 
    6325                 :            :   void record_access_failure (tree basetype_path, tree decl, tree diag_decl);
    6326                 :            : 
    6327                 :    7199580 :   bool was_inaccessible_p () const { return m_was_inaccessible; }
    6328                 :         14 :   tree get_decl () const { return m_decl; }
    6329                 :         49 :   tree get_diag_decl () const { return m_diag_decl; }
    6330                 :            :   tree get_any_accessor (bool const_p) const;
    6331                 :            :   void maybe_suggest_accessor (bool const_p) const;
    6332                 :            :   static void add_fixit_hint (rich_location *richloc, tree accessor);
    6333                 :            : 
    6334                 :            :  private:
    6335                 :            :   bool m_was_inaccessible;
    6336                 :            :   tree m_basetype_path;
    6337                 :            :   tree m_decl;
    6338                 :            :   tree m_diag_decl;
    6339                 :            : };
    6340                 :            : 
    6341                 :            : extern void complain_about_access               (tree, tree, bool);
    6342                 :            : extern bool enforce_access                      (tree, tree, tree,
    6343                 :            :                                                  tsubst_flags_t,
    6344                 :            :                                                  access_failure_info *afi = NULL);
    6345                 :            : extern void push_defarg_context                 (tree);
    6346                 :            : extern void pop_defarg_context                  (void);
    6347                 :            : extern tree convert_default_arg                 (tree, tree, tree, int,
    6348                 :            :                                                  tsubst_flags_t);
    6349                 :            : extern tree convert_arg_to_ellipsis             (tree, tsubst_flags_t);
    6350                 :            : extern tree build_x_va_arg                      (location_t, tree, tree);
    6351                 :            : extern tree cxx_type_promotes_to                (tree);
    6352                 :            : extern tree type_passed_as                      (tree);
    6353                 :            : extern tree convert_for_arg_passing             (tree, tree, tsubst_flags_t);
    6354                 :            : extern bool is_properly_derived_from            (tree, tree);
    6355                 :            : extern tree initialize_reference                (tree, tree, int,
    6356                 :            :                                                  tsubst_flags_t);
    6357                 :            : extern tree extend_ref_init_temps               (tree, tree,
    6358                 :            :                                                  vec<tree, va_gc>**,
    6359                 :            :                                                  tree * = NULL);
    6360                 :            : extern tree make_temporary_var_for_ref_to_temp  (tree, tree);
    6361                 :            : extern bool type_has_extended_temps             (tree);
    6362                 :            : extern tree strip_top_quals                     (tree);
    6363                 :            : extern bool reference_related_p                 (tree, tree);
    6364                 :            : extern bool reference_compatible_p              (tree, tree);
    6365                 :            : extern int remaining_arguments                  (tree);
    6366                 :            : extern tree perform_implicit_conversion         (tree, tree, tsubst_flags_t);
    6367                 :            : extern tree perform_implicit_conversion_flags   (tree, tree, tsubst_flags_t, int);
    6368                 :            : extern tree build_converted_constant_expr       (tree, tree, tsubst_flags_t);
    6369                 :            : extern tree build_converted_constant_bool_expr  (tree, tsubst_flags_t);
    6370                 :            : extern tree perform_direct_initialization_if_possible (tree, tree, bool,
    6371                 :            :                                                        tsubst_flags_t);
    6372                 :            : extern vec<tree,va_gc> *resolve_args (vec<tree,va_gc>*, tsubst_flags_t);
    6373                 :            : extern tree in_charge_arg_for_name              (tree);
    6374                 :            : extern tree build_cxx_call                      (tree, int, tree *,
    6375                 :            :                                                  tsubst_flags_t,
    6376                 :            :                                                  tree = NULL_TREE);
    6377                 :            : extern bool is_std_init_list                    (tree);
    6378                 :            : extern bool is_list_ctor                        (tree);
    6379                 :            : extern void validate_conversion_obstack         (void);
    6380                 :            : extern void mark_versions_used                  (tree);
    6381                 :            : extern bool cp_warn_deprecated_use              (tree, tsubst_flags_t = tf_warning_or_error);
    6382                 :            : extern void cp_warn_deprecated_use_scopes       (tree);
    6383                 :            : extern tree get_function_version_dispatcher     (tree);
    6384                 :            : 
    6385                 :            : /* in class.c */
    6386                 :            : extern tree build_vfield_ref                    (tree, tree);
    6387                 :            : extern tree build_if_in_charge                  (tree true_stmt, tree false_stmt = void_node);
    6388                 :            : extern tree build_base_path                     (enum tree_code, tree,
    6389                 :            :                                                  tree, int, tsubst_flags_t);
    6390                 :            : extern tree convert_to_base                     (tree, tree, bool, bool,
    6391                 :            :                                                  tsubst_flags_t);
    6392                 :            : extern tree convert_to_base_statically          (tree, tree);
    6393                 :            : extern tree build_vtbl_ref                      (tree, tree);
    6394                 :            : extern tree build_vfn_ref                       (tree, tree);
    6395                 :            : extern tree get_vtable_decl                     (tree, int);
    6396                 :            : extern bool add_method                          (tree, tree, bool);
    6397                 :            : extern tree declared_access                     (tree);
    6398                 :            : extern tree currently_open_class                (tree);
    6399                 :            : extern tree currently_open_derived_class        (tree);
    6400                 :            : extern tree outermost_open_class                (void);
    6401                 :            : extern tree current_nonlambda_class_type        (void);
    6402                 :            : extern tree finish_struct                       (tree, tree);
    6403                 :            : extern void finish_struct_1                     (tree);
    6404                 :            : extern int resolves_to_fixed_type_p             (tree, int *);
    6405                 :            : extern void init_class_processing               (void);
    6406                 :            : extern int is_empty_class                       (tree);
    6407                 :            : extern bool is_really_empty_class               (tree, bool);
    6408                 :            : extern void pushclass                           (tree);
    6409                 :            : extern void popclass                            (void);
    6410                 :            : extern void push_nested_class                   (tree);
    6411                 :            : extern void pop_nested_class                    (void);
    6412                 :            : extern int current_lang_depth                   (void);
    6413                 :            : extern void push_lang_context                   (tree);
    6414                 :            : extern void pop_lang_context                    (void);
    6415                 :            : extern tree instantiate_type                    (tree, tree, tsubst_flags_t);
    6416                 :            : extern void build_self_reference                (void);
    6417                 :            : extern int same_signature_p                     (const_tree, const_tree);
    6418                 :            : extern void maybe_add_class_template_decl_list  (tree, tree, int);
    6419                 :            : extern void unreverse_member_declarations       (tree);
    6420                 :            : extern void invalidate_class_lookup_cache       (void);
    6421                 :            : extern void maybe_note_name_used_in_class       (tree, tree);
    6422                 :            : extern void note_name_declared_in_class         (tree, tree);
    6423                 :            : extern tree get_vtbl_decl_for_binfo             (tree);
    6424                 :            : extern bool vptr_via_virtual_p                  (tree);
    6425                 :            : extern void debug_class                         (tree);
    6426                 :            : extern void debug_thunks                        (tree);
    6427                 :            : extern void set_linkage_according_to_type       (tree, tree);
    6428                 :            : extern void determine_key_method                (tree);
    6429                 :            : extern void check_for_override                  (tree, tree);
    6430                 :            : extern void push_class_stack                    (void);
    6431                 :            : extern void pop_class_stack                     (void);
    6432                 :            : extern bool default_ctor_p                      (const_tree);
    6433                 :            : extern bool type_has_user_nondefault_constructor (tree);
    6434                 :            : extern tree in_class_defaulted_default_constructor (tree);
    6435                 :            : extern bool user_provided_p                     (tree);
    6436                 :            : extern bool type_has_user_provided_constructor  (tree);
    6437                 :            : extern bool type_has_non_user_provided_default_constructor (tree);
    6438                 :            : extern bool vbase_has_user_provided_move_assign (tree);
    6439                 :            : extern tree default_init_uninitialized_part (tree);
    6440                 :            : extern bool trivial_default_constructor_is_constexpr (tree);
    6441                 :            : extern bool type_has_constexpr_default_constructor (tree);
    6442                 :            : extern bool type_has_constexpr_destructor       (tree);
    6443                 :            : extern bool type_has_virtual_destructor         (tree);
    6444                 :            : extern bool classtype_has_move_assign_or_move_ctor_p (tree, bool user_declared);
    6445                 :            : extern bool classtype_has_non_deleted_move_ctor (tree);
    6446                 :            : extern bool classtype_has_non_deleted_copy_ctor (tree);
    6447                 :            : extern tree classtype_has_depr_implicit_copy    (tree);
    6448                 :            : extern bool classtype_has_op (tree, tree_code);
    6449                 :            : extern tree classtype_has_defaulted_op (tree, tree_code);
    6450                 :            : extern bool type_build_ctor_call                (tree);
    6451                 :            : extern bool type_build_dtor_call                (tree);
    6452                 :            : extern void explain_non_literal_class           (tree);
    6453                 :            : extern void inherit_targ_abi_tags               (tree);
    6454                 :            : extern void defaulted_late_check                (tree);
    6455                 :            : extern bool defaultable_fn_check                (tree);
    6456                 :            : extern void check_abi_tags                      (tree);
    6457                 :            : extern tree missing_abi_tags                    (tree);
    6458                 :            : extern void fixup_type_variants                 (tree);
    6459                 :            : extern void fixup_attribute_variants            (tree);
    6460                 :            : extern void clone_function_decl                 (tree, bool);
    6461                 :            : extern void adjust_clone_args                   (tree);
    6462                 :            : extern void deduce_noexcept_on_destructor       (tree);
    6463                 :            : extern bool uniquely_derived_from_p             (tree, tree);
    6464                 :            : extern bool publicly_uniquely_derived_p         (tree, tree);
    6465                 :            : extern tree common_enclosing_class              (tree, tree);
    6466                 :            : 
    6467                 :            : /* in cvt.c */
    6468                 :            : extern tree convert_to_reference                (tree, tree, int, int, tree,
    6469                 :            :                                                  tsubst_flags_t);
    6470                 :            : extern tree convert_from_reference              (tree);
    6471                 :            : extern tree force_rvalue                        (tree, tsubst_flags_t);
    6472                 :            : extern tree ocp_convert                         (tree, tree, int, int,
    6473                 :            :                                                  tsubst_flags_t);
    6474                 :            : extern tree cp_convert                          (tree, tree, tsubst_flags_t);
    6475                 :            : extern tree cp_convert_and_check                (tree, tree, tsubst_flags_t);
    6476                 :            : extern tree cp_fold_convert                     (tree, tree);
    6477                 :            : extern tree cp_get_callee                       (tree);
    6478                 :            : extern tree cp_get_callee_fndecl                (tree);
    6479                 :            : extern tree cp_get_callee_fndecl_nofold         (tree);
    6480                 :            : extern tree cp_get_fndecl_from_callee           (tree, bool fold = true);
    6481                 :            : extern tree convert_to_void                     (tree, impl_conv_void,
    6482                 :            :                                                  tsubst_flags_t);
    6483                 :            : extern tree convert_force                       (tree, tree, int,
    6484                 :            :                                                  tsubst_flags_t);
    6485                 :            : extern tree build_expr_type_conversion          (int, tree, bool);
    6486                 :            : extern tree type_promotes_to                    (tree);
    6487                 :            : extern bool can_convert_qual                    (tree, tree);
    6488                 :            : extern tree perform_qualification_conversions   (tree, tree);
    6489                 :            : extern bool tx_safe_fn_type_p                   (tree);
    6490                 :            : extern tree tx_unsafe_fn_variant                (tree);
    6491                 :            : extern bool fnptr_conv_p                        (tree, tree);
    6492                 :            : extern tree strip_fnptr_conv                    (tree);
    6493                 :            : 
    6494                 :            : /* in name-lookup.c */
    6495                 :            : extern void maybe_push_cleanup_level            (tree);
    6496                 :            : extern tree maybe_push_decl                     (tree);
    6497                 :            : extern tree current_decl_namespace              (void);
    6498                 :            : 
    6499                 :            : /* decl.c */
    6500                 :            : extern tree poplevel                            (int, int, int);
    6501                 :            : extern void cxx_init_decl_processing            (void);
    6502                 :            : enum cp_tree_node_structure_enum cp_tree_node_structure
    6503                 :            :                                                 (union lang_tree_node *);
    6504                 :            : extern void finish_scope                        (void);
    6505                 :            : extern void push_switch                         (tree);
    6506                 :            : extern void pop_switch                          (void);
    6507                 :            : extern void note_break_stmt                     (void);
    6508                 :            : extern bool note_iteration_stmt_body_start      (void);
    6509                 :            : extern void note_iteration_stmt_body_end        (bool);
    6510                 :            : extern void determine_local_discriminator       (tree);
    6511                 :            : extern int decls_match                          (tree, tree, bool = true);
    6512                 :            : extern bool maybe_version_functions             (tree, tree, bool);
    6513                 :            : extern tree duplicate_decls                     (tree, tree, bool);
    6514                 :            : extern tree declare_local_label                 (tree);
    6515                 :            : extern tree define_label                        (location_t, tree);
    6516                 :            : extern void check_goto                          (tree);
    6517                 :            : extern bool check_omp_return                    (void);
    6518                 :            : extern tree make_typename_type                  (tree, tree, enum tag_types, tsubst_flags_t);
    6519                 :            : extern tree build_typename_type                 (tree, tree, tree, tag_types);
    6520                 :            : extern tree make_unbound_class_template         (tree, tree, tree, tsubst_flags_t);
    6521                 :            : extern tree build_library_fn_ptr                (const char *, tree, int);
    6522                 :            : extern tree build_cp_library_fn_ptr             (const char *, tree, int);
    6523                 :            : extern tree push_library_fn                     (tree, tree, tree, int);
    6524                 :            : extern tree push_void_library_fn                (tree, tree, int);
    6525                 :            : extern tree push_throw_library_fn               (tree, tree);
    6526                 :            : extern void warn_misplaced_attr_for_class_type  (location_t location,
    6527                 :            :                                                  tree class_type);
    6528                 :            : extern tree check_tag_decl                      (cp_decl_specifier_seq *, bool);
    6529                 :            : extern tree shadow_tag                          (cp_decl_specifier_seq *);
    6530                 :            : extern tree groktypename                        (cp_decl_specifier_seq *, const cp_declarator *, bool);
    6531                 :            : extern tree start_decl                          (const cp_declarator *, cp_decl_specifier_seq *, int, tree, tree, tree *);
    6532                 :            : extern void start_decl_1                        (tree, bool);
    6533                 :            : extern bool check_array_initializer             (tree, tree, tree);
    6534                 :            : extern void omp_declare_variant_finalize        (tree, tree);
    6535                 :            : extern void cp_finish_decl                      (tree, tree, bool, tree, int);
    6536                 :            : extern tree lookup_decomp_type                  (tree);
    6537                 :            : extern void cp_maybe_mangle_decomp              (tree, tree, unsigned int);
    6538                 :            : extern void cp_finish_decomp                    (tree, tree, unsigned int);
    6539                 :            : extern int cp_complete_array_type               (tree *, tree, bool);
    6540                 :            : extern int cp_complete_array_type_or_error      (tree *, tree, bool, tsubst_flags_t);
    6541                 :            : extern tree build_ptrmemfunc_type               (tree);
    6542                 :            : extern tree build_ptrmem_type                   (tree, tree);
    6543                 :            : /* the grokdeclarator prototype is in decl.h */
    6544                 :            : extern tree build_this_parm                     (tree, tree, cp_cv_quals);
    6545                 :            : extern tree grokparms                           (tree, tree *);
    6546                 :            : extern int copy_fn_p                            (const_tree);
    6547                 :            : extern bool move_fn_p                           (const_tree);
    6548                 :            : extern bool move_signature_fn_p                 (const_tree);
    6549                 :            : extern tree get_scope_of_declarator             (const cp_declarator *);
    6550                 :            : extern void grok_special_member_properties      (tree);
    6551                 :            : extern bool grok_ctor_properties                (const_tree, const_tree);
    6552                 :            : extern bool grok_op_properties                  (tree, bool);
    6553                 :            : extern tree xref_tag                            (enum tag_types, tree, tag_scope, bool);
    6554                 :            : extern tree xref_tag_from_type                  (tree, tree, tag_scope);
    6555                 :            : extern void xref_basetypes                      (tree, tree);
    6556                 :            : extern tree start_enum                          (tree, tree, tree, tree, bool, bool *);
    6557                 :            : extern void finish_enum_value_list              (tree);
    6558                 :            : extern void finish_enum                         (tree);
    6559                 :            : extern void build_enumerator                    (tree, tree, tree, tree, location_t);
    6560                 :            : extern tree lookup_enumerator                   (tree, tree);
    6561                 :            : extern bool start_preparsed_function            (tree, tree, int);
    6562                 :            : extern bool start_function                      (cp_decl_specifier_seq *,
    6563                 :            :                                                  const cp_declarator *, tree);
    6564                 :            : extern tree begin_function_body                 (void);
    6565                 :            : extern void finish_function_body                (tree);
    6566                 :            : extern tree outer_curly_brace_block             (tree);
    6567                 :            : extern tree finish_function                     (bool);
    6568                 :            : extern tree grokmethod                          (cp_decl_specifier_seq *, const cp_declarator *, tree);
    6569                 :            : extern void maybe_register_incomplete_var       (tree);
    6570                 :            : extern void maybe_commonize_var                 (tree);
    6571                 :            : extern void complete_vars                       (tree);
    6572                 :            : extern tree static_fn_type                      (tree);
    6573                 :            : extern void revert_static_member_fn             (tree);
    6574                 :            : extern void fixup_anonymous_aggr                (tree);
    6575                 :            : extern tree compute_array_index_type            (tree, tree, tsubst_flags_t);
    6576                 :            : extern tree check_default_argument              (tree, tree, tsubst_flags_t);
    6577                 :            : extern int wrapup_namespace_globals             ();
    6578                 :            : extern tree create_implicit_typedef             (tree, tree);
    6579                 :            : extern int local_variable_p                     (const_tree);
    6580                 :            : extern tree register_dtor_fn                    (tree);
    6581                 :            : extern tmpl_spec_kind current_tmpl_spec_kind    (int);
    6582                 :            : extern tree cp_fname_init                       (const char *, tree *);
    6583                 :            : extern tree cxx_builtin_function                (tree decl);
    6584                 :            : extern tree cxx_builtin_function_ext_scope      (tree decl);
    6585                 :            : extern tree cxx_simulate_builtin_function_decl  (tree);
    6586                 :            : extern tree check_elaborated_type_specifier     (enum tag_types, tree, bool);
    6587                 :            : extern void warn_extern_redeclared_static       (tree, tree);
    6588                 :            : extern tree cxx_comdat_group                    (tree);
    6589                 :            : extern bool cp_missing_noreturn_ok_p            (tree);
    6590                 :            : extern bool is_direct_enum_init                 (tree, tree);
    6591                 :            : extern void initialize_artificial_var           (tree, vec<constructor_elt, va_gc> *);
    6592                 :            : extern tree check_var_type                      (tree, tree, location_t);
    6593                 :            : extern tree reshape_init                        (tree, tree, tsubst_flags_t);
    6594                 :            : extern tree next_initializable_field (tree);
    6595                 :            : extern tree fndecl_declared_return_type         (tree);
    6596                 :            : extern bool undeduced_auto_decl                 (tree);
    6597                 :            : extern bool require_deduced_type                (tree, tsubst_flags_t = tf_warning_or_error);
    6598                 :            : 
    6599                 :            : extern tree finish_case_label                   (location_t, tree, tree);
    6600                 :            : extern tree cxx_maybe_build_cleanup             (tree, tsubst_flags_t);
    6601                 :            : extern bool check_array_designated_initializer  (constructor_elt *,
    6602                 :            :                                                  unsigned HOST_WIDE_INT);
    6603                 :            : extern bool check_for_uninitialized_const_var   (tree, bool, tsubst_flags_t);
    6604                 :            : extern tree build_explicit_specifier            (tree, tsubst_flags_t);
    6605                 :            : extern void do_push_parm_decls                  (tree, tree, tree *);
    6606                 :            : 
    6607                 :            : /* in decl2.c */
    6608                 :            : extern void record_mangling                     (tree, bool);
    6609                 :            : extern void overwrite_mangling                  (tree, tree);
    6610                 :            : extern void note_mangling_alias                 (tree, tree);
    6611                 :            : extern void generate_mangling_aliases           (void);
    6612                 :            : extern tree build_memfn_type                    (tree, tree, cp_cv_quals, cp_ref_qualifier);
    6613                 :            : extern tree build_pointer_ptrmemfn_type (tree);
    6614                 :            : extern tree change_return_type                  (tree, tree);
    6615                 :            : extern void maybe_retrofit_in_chrg              (tree);
    6616                 :            : extern void maybe_make_one_only                 (tree);
    6617                 :            : extern bool vague_linkage_p                     (tree);
    6618                 :            : extern void grokclassfn                         (tree, tree,
    6619                 :            :                                                  enum overload_flags);
    6620                 :            : extern tree grok_array_decl                     (location_t, tree, tree, bool);
    6621                 :            : extern tree delete_sanity                       (location_t, tree, tree, bool,
    6622                 :            :                                                  int, tsubst_flags_t);
    6623                 :            : extern tree check_classfn                       (tree, tree, tree);
    6624                 :            : extern void check_member_template               (tree);
    6625                 :            : extern tree grokfield (const cp_declarator *, cp_decl_specifier_seq *,
    6626                 :            :                        tree, bool, tree, tree);
    6627                 :            : extern tree grokbitfield (const cp_declarator *, cp_decl_specifier_seq *,
    6628                 :            :                           tree, tree, tree);
    6629                 :            : extern bool any_dependent_type_attributes_p     (tree);
    6630                 :            : extern tree cp_reconstruct_complex_type         (tree, tree);
    6631                 :            : extern bool attributes_naming_typedef_ok        (tree);
    6632                 :            : extern void cplus_decl_attributes               (tree *, tree, int);
    6633                 :            : extern void finish_anon_union                   (tree);
    6634                 :            : extern void cxx_post_compilation_parsing_cleanups (void);
    6635                 :            : extern tree coerce_new_type                     (tree, location_t);
    6636                 :            : extern void coerce_delete_type                  (tree, location_t);
    6637                 :            : extern void comdat_linkage                      (tree);
    6638                 :            : extern void determine_visibility                (tree);
    6639                 :            : extern void constrain_class_visibility          (tree);
    6640                 :            : extern void reset_type_linkage                  (tree);
    6641                 :            : extern void tentative_decl_linkage              (tree);
    6642                 :            : extern void import_export_decl                  (tree);
    6643                 :            : extern tree build_cleanup                       (tree);
    6644                 :            : extern tree build_offset_ref_call_from_tree     (tree, vec<tree, va_gc> **,
    6645                 :            :                                                  tsubst_flags_t);
    6646                 :            : extern bool decl_defined_p                      (tree);
    6647                 :            : extern bool decl_constant_var_p                 (tree);
    6648                 :            : extern bool decl_maybe_constant_var_p           (tree);
    6649                 :            : extern void no_linkage_error                    (tree);
    6650                 :            : extern void check_default_args                  (tree);
    6651                 :            : extern bool mark_used                           (tree);
    6652                 :            : extern bool mark_used                           (tree, tsubst_flags_t);
    6653                 :            : extern void finish_static_data_member_decl      (tree, tree, bool, tree, int);
    6654                 :            : extern tree cp_build_parm_decl                  (tree, tree, tree);
    6655                 :            : extern void copy_linkage                        (tree, tree);
    6656                 :            : extern tree get_guard                           (tree);
    6657                 :            : extern tree get_guard_cond                      (tree, bool);
    6658                 :            : extern tree set_guard                           (tree);
    6659                 :            : extern tree maybe_get_tls_wrapper_call          (tree);
    6660                 :            : extern void mark_needed                         (tree);
    6661                 :            : extern bool decl_needed_p                       (tree);
    6662                 :            : extern void note_vague_linkage_fn               (tree);
    6663                 :            : extern void note_variable_template_instantiation (tree);
    6664                 :            : extern tree build_artificial_parm               (tree, tree, tree);
    6665                 :            : extern bool possibly_inlined_p                  (tree);
    6666                 :            : extern int parm_index                           (tree);
    6667                 :            : extern tree vtv_start_verification_constructor_init_function (void);
    6668                 :            : extern tree vtv_finish_verification_constructor_init_function (tree);
    6669                 :            : extern bool cp_omp_mappable_type                (tree);
    6670                 :            : extern bool cp_omp_emit_unmappable_type_notes   (tree);
    6671                 :            : extern void cp_check_const_attributes (tree);
    6672                 :            : 
    6673                 :            : /* in error.c */
    6674                 :            : extern const char *type_as_string               (tree, int);
    6675                 :            : extern const char *type_as_string_translate     (tree, int);
    6676                 :            : extern const char *decl_as_string               (tree, int);
    6677                 :            : extern const char *decl_as_string_translate     (tree, int);
    6678                 :            : extern const char *decl_as_dwarf_string         (tree, int);
    6679                 :            : extern const char *expr_as_string               (tree, int);
    6680                 :            : extern const char *expr_to_string               (tree);
    6681                 :            : extern const char *lang_decl_name               (tree, int, bool);
    6682                 :            : extern const char *lang_decl_dwarf_name         (tree, int, bool);
    6683                 :            : extern const char *language_to_string           (enum languages);
    6684                 :            : extern const char *class_key_or_enum_as_string  (tree);
    6685                 :            : extern void maybe_warn_variadic_templates       (void);
    6686                 :            : extern void maybe_warn_cpp0x                    (cpp0x_warn_str str);
    6687                 :            : extern bool pedwarn_cxx98                       (location_t, int, const char *, ...) ATTRIBUTE_GCC_DIAG(3,4);
    6688                 :            : extern location_t location_of                   (tree);
    6689                 :            : extern void qualified_name_lookup_error         (tree, tree, tree,
    6690                 :            :                                                  location_t);
    6691                 :            : 
    6692                 :            : /* in except.c */
    6693                 :            : extern void init_exception_processing           (void);
    6694                 :            : extern tree expand_start_catch_block            (tree);
    6695                 :            : extern void expand_end_catch_block              (void);
    6696                 :            : extern tree build_exc_ptr                       (void);
    6697                 :            : extern tree build_throw                         (location_t, tree);
    6698                 :            : extern int nothrow_libfn_p                      (const_tree);
    6699                 :            : extern void check_handlers                      (tree);
    6700                 :            : extern tree finish_noexcept_expr                (tree, tsubst_flags_t);
    6701                 :            : extern bool expr_noexcept_p                     (tree, tsubst_flags_t);
    6702                 :            : extern void perform_deferred_noexcept_checks    (void);
    6703                 :            : extern bool nothrow_spec_p                      (const_tree);
    6704                 :            : extern bool type_noexcept_p                     (const_tree);
    6705                 :            : extern bool type_throw_all_p                    (const_tree);
    6706                 :            : extern tree build_noexcept_spec                 (tree, tsubst_flags_t);
    6707                 :            : extern void choose_personality_routine          (enum languages);
    6708                 :            : extern tree build_must_not_throw_expr           (tree,tree);
    6709                 :            : extern tree eh_type_info                        (tree);
    6710                 :            : extern tree begin_eh_spec_block                 (void);
    6711                 :            : extern void finish_eh_spec_block                (tree, tree);
    6712                 :            : extern tree build_eh_type_type                  (tree);
    6713                 :            : extern tree cp_protect_cleanup_actions          (void);
    6714                 :            : extern void maybe_splice_retval_cleanup         (tree);
    6715                 :            : extern tree maybe_set_retval_sentinel           (void);
    6716                 :            : 
    6717                 :            : extern tree template_parms_to_args              (tree);
    6718                 :            : extern tree template_parms_level_to_args        (tree);
    6719                 :            : extern tree generic_targs_for                   (tree);
    6720                 :            : 
    6721                 :            : /* in expr.c */
    6722                 :            : extern tree cplus_expand_constant               (tree);
    6723                 :            : extern tree mark_use (tree expr, bool rvalue_p, bool read_p,
    6724                 :            :                       location_t = UNKNOWN_LOCATION,
    6725                 :            :                       bool reject_builtin = true);
    6726                 :            : extern tree mark_rvalue_use                     (tree,
    6727                 :            :                                                  location_t = UNKNOWN_LOCATION,
    6728                 :            :                                                  bool reject_builtin = true);
    6729                 :            : extern tree mark_lvalue_use                     (tree);
    6730                 :            : extern tree mark_lvalue_use_nonread             (tree);
    6731                 :            : extern tree mark_type_use                       (tree);
    6732                 :            : extern tree mark_discarded_use                  (tree);
    6733                 :            : extern void mark_exp_read                       (tree);
    6734                 :            : 
    6735                 :            : /* friend.c */
    6736                 :            : extern int is_friend                            (tree, tree);
    6737                 :            : extern void make_friend_class                   (tree, tree, bool);
    6738                 :            : extern void add_friend                          (tree, tree, bool);
    6739                 :            : extern tree do_friend                           (tree, tree, tree, tree,
    6740                 :            :                                                  enum overload_flags, bool);
    6741                 :            : 
    6742                 :            : extern void set_global_friend                   (tree);
    6743                 :            : extern bool is_global_friend                    (tree);
    6744                 :            : 
    6745                 :            : /* in init.c */
    6746                 :            : extern tree expand_member_init                  (tree);
    6747                 :            : extern void emit_mem_initializers               (tree);
    6748                 :            : extern tree build_aggr_init                     (tree, tree, int,
    6749                 :            :                                                  tsubst_flags_t);
    6750                 :            : extern int is_class_type                        (tree, int);
    6751                 :            : extern tree get_type_value                      (tree);
    6752                 :            : extern tree build_zero_init                     (tree, tree, bool);
    6753                 :            : extern tree build_value_init                    (tree, tsubst_flags_t);
    6754                 :            : extern tree build_value_init_noctor             (tree, tsubst_flags_t);
    6755                 :            : extern tree get_nsdmi                           (tree, bool, tsubst_flags_t);
    6756                 :            : extern tree build_offset_ref                    (tree, tree, bool,
    6757                 :            :                                                  tsubst_flags_t);
    6758                 :            : extern tree throw_bad_array_new_length          (void);
    6759                 :            : extern bool type_has_new_extended_alignment     (tree);
    6760                 :            : extern unsigned malloc_alignment                (void);
    6761                 :            : extern tree build_new_constexpr_heap_type       (tree, tree, tree);
    6762                 :            : extern tree build_new                           (location_t,
    6763                 :            :                                                  vec<tree, va_gc> **, tree,
    6764                 :            :                                                  tree, vec<tree, va_gc> **,
    6765                 :            :                                                  int, tsubst_flags_t);
    6766                 :            : extern tree get_temp_regvar                     (tree, tree);
    6767                 :            : extern tree build_vec_init                      (tree, tree, tree, bool, int,
    6768                 :            :                                                  tsubst_flags_t);
    6769                 :            : extern tree build_delete                        (location_t, tree, tree,
    6770                 :            :                                                  special_function_kind,
    6771                 :            :                                                  int, int, tsubst_flags_t);
    6772                 :            : extern void push_base_cleanups                  (void);
    6773                 :            : extern tree build_vec_delete                    (location_t, tree, tree,
    6774                 :            :                                                  special_function_kind, int,
    6775                 :            :                                                  tsubst_flags_t);
    6776                 :            : extern tree create_temporary_var                (tree);
    6777                 :            : extern void initialize_vtbl_ptrs                (tree);
    6778                 :            : extern tree scalar_constant_value               (tree);
    6779                 :            : extern tree decl_really_constant_value          (tree);
    6780                 :            : extern int diagnose_uninitialized_cst_or_ref_member (tree, bool, bool);
    6781                 :            : extern tree build_vtbl_address                  (tree);
    6782                 :            : extern bool maybe_reject_flexarray_init         (tree, tree);
    6783                 :            : 
    6784                 :            : /* in lex.c */
    6785                 :            : extern void cxx_dup_lang_specific_decl          (tree);
    6786                 :            : extern void yyungetc                            (int, int);
    6787                 :            : 
    6788                 :            : extern tree unqualified_name_lookup_error       (tree,
    6789                 :            :                                                  location_t = UNKNOWN_LOCATION);
    6790                 :            : extern tree unqualified_fn_lookup_error         (cp_expr);
    6791                 :            : extern tree make_conv_op_name                   (tree);
    6792                 :            : extern tree build_lang_decl                     (enum tree_code, tree, tree);
    6793                 :            : extern tree build_lang_decl_loc                 (location_t, enum tree_code, tree, tree);
    6794                 :            : extern void retrofit_lang_decl                  (tree);
    6795                 :            : extern void fit_decomposition_lang_decl         (tree, tree);
    6796                 :            : extern tree copy_decl                           (tree CXX_MEM_STAT_INFO);
    6797                 :            : extern tree copy_type                           (tree CXX_MEM_STAT_INFO);
    6798                 :            : extern tree cxx_make_type                       (enum tree_code CXX_MEM_STAT_INFO);
    6799                 :            : extern tree make_class_type                     (enum tree_code CXX_MEM_STAT_INFO);
    6800                 :            : extern const char *get_identifier_kind_name     (tree);
    6801                 :            : extern void set_identifier_kind                 (tree, cp_identifier_kind);
    6802                 :            : extern bool cxx_init                            (void);
    6803                 :            : extern void cxx_finish                          (void);
    6804                 :            : extern bool in_main_input_context               (void);
    6805                 :            : 
    6806                 :            : /* in method.c */
    6807                 :            : extern void init_method                         (void);
    6808                 :            : extern tree make_thunk                          (tree, bool, tree, tree);
    6809                 :            : extern void finish_thunk                        (tree);
    6810                 :            : extern void use_thunk                           (tree, bool);
    6811                 :            : extern bool trivial_fn_p                        (tree);
    6812                 :            : extern tree forward_parm                        (tree);
    6813                 :            : extern bool is_trivially_xible                  (enum tree_code, tree, tree);
    6814                 :            : extern bool is_xible                            (enum tree_code, tree, tree);
    6815                 :            : extern tree get_defaulted_eh_spec               (tree, tsubst_flags_t = tf_warning_or_error);
    6816                 :            : extern void after_nsdmi_defaulted_late_checks   (tree);
    6817                 :            : extern bool maybe_explain_implicit_delete       (tree);
    6818                 :            : extern void explain_implicit_non_constexpr      (tree);
    6819                 :            : extern void deduce_inheriting_ctor              (tree);
    6820                 :            : extern bool decl_remember_implicit_trigger_p    (tree);
    6821                 :            : extern void synthesize_method                   (tree);
    6822                 :            : extern tree lazily_declare_fn                   (special_function_kind,
    6823                 :            :                                                  tree);
    6824                 :            : extern tree skip_artificial_parms_for           (const_tree, tree);
    6825                 :            : extern int num_artificial_parms_for             (const_tree);
    6826                 :            : extern tree make_alias_for                      (tree, tree);
    6827                 :            : extern tree get_copy_ctor                       (tree, tsubst_flags_t);
    6828                 :            : extern tree get_copy_assign                     (tree);
    6829                 :            : extern tree get_default_ctor                    (tree);
    6830                 :            : extern tree get_dtor                            (tree, tsubst_flags_t);
    6831                 :            : extern tree strip_inheriting_ctors              (tree);
    6832                 :            : extern tree inherited_ctor_binfo                (tree);
    6833                 :            : extern bool ctor_omit_inherited_parms           (tree);
    6834                 :            : extern tree locate_ctor                         (tree);
    6835                 :            : extern tree implicitly_declare_fn               (special_function_kind, tree,
    6836                 :            :                                                  bool, tree, tree);
    6837                 :            : 
    6838                 :            : /* In optimize.c */
    6839                 :            : extern bool maybe_clone_body                    (tree);
    6840                 :            : 
    6841                 :            : /* In parser.c */
    6842                 :            : extern tree cp_convert_range_for (tree, tree, tree, tree, unsigned int, bool,
    6843                 :            :                                   unsigned short);
    6844                 :            : extern void cp_convert_omp_range_for (tree &, vec<tree, va_gc> *, tree &,
    6845                 :            :                                       tree &, tree &, tree &, tree &, tree &);
    6846                 :            : extern void cp_finish_omp_range_for (tree, tree);
    6847                 :            : extern bool parsing_nsdmi (void);
    6848                 :            : extern bool parsing_default_capturing_generic_lambda_in_template (void);
    6849                 :            : extern void inject_this_parameter (tree, cp_cv_quals);
    6850                 :            : extern location_t defparse_location (tree);
    6851                 :            : extern void maybe_show_extern_c_location (void);
    6852                 :            : extern bool literal_integer_zerop (const_tree);
    6853                 :            : 
    6854                 :            : /* in pt.c */
    6855                 :            : extern void push_access_scope                   (tree);
    6856                 :            : extern void pop_access_scope                    (tree);
    6857                 :            : extern bool check_template_shadow               (tree);
    6858                 :            : extern bool check_auto_in_tmpl_args             (tree, tree);
    6859                 :            : extern tree get_innermost_template_args         (tree, int);
    6860                 :            : extern void maybe_begin_member_template_processing (tree);
    6861                 :            : extern void maybe_end_member_template_processing (void);
    6862                 :            : extern tree finish_member_template_decl         (tree);
    6863                 :            : extern void begin_template_parm_list            (void);
    6864                 :            : extern bool begin_specialization                (void);
    6865                 :            : extern void reset_specialization                (void);
    6866                 :            : extern void end_specialization                  (void);
    6867                 :            : extern void begin_explicit_instantiation        (void);
    6868                 :            : extern void end_explicit_instantiation          (void);
    6869                 :            : extern void check_unqualified_spec_or_inst      (tree, location_t);
    6870                 :            : extern tree check_explicit_specialization       (tree, tree, int, int,
    6871                 :            :                                                  tree = NULL_TREE);
    6872                 :            : extern int num_template_headers_for_class       (tree);
    6873                 :            : extern void check_template_variable             (tree);
    6874                 :            : extern tree make_auto                           (void);
    6875                 :            : extern tree make_decltype_auto                  (void);
    6876                 :            : extern tree make_constrained_auto               (tree, tree);
    6877                 :            : extern tree make_constrained_decltype_auto      (tree, tree);
    6878                 :            : extern tree make_template_placeholder           (tree);
    6879                 :            : extern bool template_placeholder_p              (tree);
    6880                 :            : extern bool ctad_template_p                     (tree);
    6881                 :            : extern tree do_auto_deduction                   (tree, tree, tree,
    6882                 :            :                                                  tsubst_flags_t
    6883                 :            :                                                  = tf_warning_or_error,
    6884                 :            :                                                  auto_deduction_context
    6885                 :            :                                                  = adc_unspecified,
    6886                 :            :                                                  tree = NULL_TREE,
    6887                 :            :                                                  int = LOOKUP_NORMAL);
    6888                 :            : extern tree type_uses_auto                      (tree);
    6889                 :            : extern tree type_uses_auto_or_concept           (tree);
    6890                 :            : extern void append_type_to_template_for_access_check (tree, tree, tree,
    6891                 :            :                                                       location_t);
    6892                 :            : extern tree convert_generic_types_to_packs      (tree, int, int);
    6893                 :            : extern tree splice_late_return_type             (tree, tree);
    6894                 :            : extern bool is_auto                             (const_tree);
    6895                 :            : extern tree process_template_parm               (tree, location_t, tree,
    6896                 :            :                                                  bool, bool);
    6897                 :            : extern tree end_template_parm_list              (tree);
    6898                 :            : extern void end_template_parm_list              (void);
    6899                 :            : extern void end_template_decl                   (void);
    6900                 :            : extern tree maybe_update_decl_type              (tree, tree);
    6901                 :            : extern bool check_default_tmpl_args             (tree, tree, bool, bool, int);
    6902                 :            : extern tree push_template_decl                  (tree);
    6903                 :            : extern tree push_template_decl_real             (tree, bool);
    6904                 :            : extern tree add_inherited_template_parms        (tree, tree);
    6905                 :            : extern void template_parm_level_and_index       (tree, int*, int*);
    6906                 :            : extern bool redeclare_class_template            (tree, tree, tree);
    6907                 :            : extern tree lookup_template_class               (tree, tree, tree, tree,
    6908                 :            :                                                  int, tsubst_flags_t);
    6909                 :            : extern tree lookup_template_function            (tree, tree);
    6910                 :            : extern tree lookup_template_variable            (tree, tree);
    6911                 :            : extern int uses_template_parms                  (tree);
    6912                 :            : extern bool uses_template_parms_level           (tree, int);
    6913                 :            : extern bool in_template_function                (void);
    6914                 :            : extern bool need_generic_capture                (void);
    6915                 :            : extern tree instantiate_class_template          (tree);
    6916                 :            : extern tree instantiate_template                (tree, tree, tsubst_flags_t);
    6917                 :            : extern tree fn_type_unification                 (tree, tree, tree,
    6918                 :            :                                                  const tree *, unsigned int,
    6919                 :            :                                                  tree, unification_kind_t, int,
    6920                 :            :                                                  struct conversion **,
    6921                 :            :                                                  bool, bool);
    6922                 :            : extern void mark_decl_instantiated              (tree, int);
    6923                 :            : extern int more_specialized_fn                  (tree, tree, int);
    6924                 :            : extern void do_decl_instantiation               (tree, tree);
    6925                 :            : extern void do_type_instantiation               (tree, tree, tsubst_flags_t);
    6926                 :            : extern bool always_instantiate_p                (tree);
    6927                 :            : extern bool maybe_instantiate_noexcept          (tree, tsubst_flags_t = tf_warning_or_error);
    6928                 :            : extern tree instantiate_decl                    (tree, bool, bool);
    6929                 :            : extern int comp_template_parms                  (const_tree, const_tree);
    6930                 :            : extern bool template_heads_equivalent_p         (const_tree, const_tree);
    6931                 :            : extern bool builtin_pack_fn_p                   (tree);
    6932                 :            : extern tree uses_parameter_packs                (tree);
    6933                 :            : extern bool template_parameter_pack_p           (const_tree);
    6934                 :            : extern bool function_parameter_pack_p           (const_tree);
    6935                 :            : extern bool function_parameter_expanded_from_pack_p (tree, tree);
    6936                 :            : extern tree make_pack_expansion                 (tree, tsubst_flags_t = tf_warning_or_error);
    6937                 :            : extern bool check_for_bare_parameter_packs      (tree, location_t = UNKNOWN_LOCATION);
    6938                 :            : extern tree build_template_info                 (tree, tree);
    6939                 :            : extern tree get_template_info                   (const_tree);
    6940                 :            : extern vec<qualified_typedef_usage_t, va_gc> *get_types_needing_access_check (tree);
    6941                 :            : extern int template_class_depth                 (tree);
    6942                 :            : extern int is_specialization_of                 (tree, tree);
    6943                 :            : extern bool is_specialization_of_friend         (tree, tree);
    6944                 :            : extern tree get_pattern_parm                    (tree, tree);
    6945                 :            : extern int comp_template_args                   (tree, tree, tree * = NULL,
    6946                 :            :                                                  tree * = NULL, bool = false);
    6947                 :            : extern int template_args_equal                  (tree, tree, bool = false);
    6948                 :            : extern tree maybe_process_partial_specialization (tree);
    6949                 :            : extern tree most_specialized_instantiation      (tree);
    6950                 :            : extern tree most_specialized_partial_spec       (tree, tsubst_flags_t);
    6951                 :            : extern void print_candidates                    (tree);
    6952                 :            : extern void instantiate_pending_templates       (int);
    6953                 :            : extern tree tsubst_default_argument             (tree, int, tree, tree,
    6954                 :            :                                                  tsubst_flags_t);
    6955                 :            : extern tree tsubst (tree, tree, tsubst_flags_t, tree);
    6956                 :            : extern tree tsubst_copy_and_build               (tree, tree, tsubst_flags_t,
    6957                 :            :                                                  tree, bool, bool);
    6958                 :            : extern tree tsubst_expr                         (tree, tree, tsubst_flags_t,
    6959                 :            :                                                  tree, bool);
    6960                 :            : extern tree tsubst_pack_expansion               (tree, tree, tsubst_flags_t, tree);
    6961                 :            : extern tree tsubst_argument_pack                (tree, tree, tsubst_flags_t, tree);
    6962                 :            : extern tree tsubst_template_args                (tree, tree, tsubst_flags_t, tree);
    6963                 :            : extern tree tsubst_template_arg                 (tree, tree, tsubst_flags_t, tree);
    6964                 :            : extern tree tsubst_function_parms               (tree, tree, tsubst_flags_t, tree);
    6965                 :            : extern tree most_general_template               (tree);
    6966                 :            : extern tree get_mostly_instantiated_function_type (tree);
    6967                 :            : extern bool problematic_instantiation_changed   (void);
    6968                 :            : extern void record_last_problematic_instantiation (void);
    6969                 :            : extern struct tinst_level *current_instantiation(void);
    6970                 :            : extern bool instantiating_current_function_p    (void);
    6971                 :            : extern tree maybe_get_template_decl_from_type_decl (tree);
    6972                 :            : extern int processing_template_parmlist;
    6973                 :            : extern bool dependent_type_p                    (tree);
    6974                 :            : extern bool dependent_scope_p                   (tree);
    6975                 :            : extern bool any_dependent_template_arguments_p  (const_tree);
    6976                 :            : extern bool any_erroneous_template_args_p       (const_tree);
    6977                 :            : extern bool dependent_template_p                (tree);
    6978                 :            : extern bool dependent_template_id_p             (tree, tree);
    6979                 :            : extern bool type_dependent_expression_p         (tree);
    6980                 :            : extern bool type_dependent_object_expression_p  (tree);
    6981                 :            : extern bool any_type_dependent_arguments_p      (const vec<tree, va_gc> *);
    6982                 :            : extern bool any_type_dependent_elements_p       (const_tree);
    6983                 :            : extern bool type_dependent_expression_p_push    (tree);
    6984                 :            : extern bool value_dependent_expression_p        (tree);
    6985                 :            : extern bool instantiation_dependent_expression_p (tree);
    6986                 :            : extern bool instantiation_dependent_uneval_expression_p (tree);
    6987                 :            : extern bool any_value_dependent_elements_p      (const_tree);
    6988                 :            : extern bool dependent_omp_for_p                 (tree, tree, tree, tree);
    6989                 :            : extern tree resolve_typename_type               (tree, bool);
    6990                 :            : extern tree template_for_substitution           (tree);
    6991                 :            : extern tree build_non_dependent_expr            (tree);
    6992                 :            : extern void make_args_non_dependent             (vec<tree, va_gc> *);
    6993                 :            : extern bool reregister_specialization           (tree, tree, tree);
    6994                 :            : extern tree instantiate_non_dependent_expr      (tree);
    6995                 :            : extern tree instantiate_non_dependent_expr_sfinae (tree, tsubst_flags_t);
    6996                 :            : extern tree instantiate_non_dependent_expr_internal (tree, tsubst_flags_t);
    6997                 :            : extern tree instantiate_non_dependent_or_null   (tree);
    6998                 :            : extern bool variable_template_specialization_p  (tree);
    6999                 :            : extern bool alias_type_or_template_p            (tree);
    7000                 :            : enum { nt_opaque = false, nt_transparent = true };
    7001                 :            : extern tree alias_template_specialization_p     (const_tree, bool);
    7002                 :            : extern tree dependent_alias_template_spec_p     (const_tree, bool);
    7003                 :            : extern bool template_parm_object_p              (const_tree);
    7004                 :            : extern bool explicit_class_specialization_p     (tree);
    7005                 :            : extern bool push_tinst_level                    (tree);
    7006                 :            : extern bool push_tinst_level_loc                (tree, location_t);
    7007                 :            : extern void pop_tinst_level                     (void);
    7008                 :            : extern struct tinst_level *outermost_tinst_level(void);
    7009                 :            : extern void init_template_processing            (void);
    7010                 :            : extern void print_template_statistics           (void);
    7011                 :            : bool template_template_parameter_p              (const_tree);
    7012                 :            : bool template_type_parameter_p                  (const_tree);
    7013                 :            : extern bool primary_template_specialization_p   (const_tree);
    7014                 :            : extern tree get_primary_template_innermost_parameters   (const_tree);
    7015                 :            : extern tree get_template_parms_at_level (tree, int);
    7016                 :            : extern tree get_template_innermost_arguments    (const_tree);
    7017                 :            : extern tree get_template_argument_pack_elems    (const_tree);
    7018                 :            : extern tree get_function_template_decl          (const_tree);
    7019                 :            : extern tree resolve_nondeduced_context          (tree, tsubst_flags_t);
    7020                 :            : extern tree resolve_nondeduced_context_or_error (tree, tsubst_flags_t);
    7021                 :            : extern hashval_t iterative_hash_template_arg (tree arg, hashval_t val);
    7022                 :            : extern tree coerce_template_parms               (tree, tree, tree);
    7023                 :            : extern tree coerce_template_parms               (tree, tree, tree, tsubst_flags_t);
    7024                 :            : extern tree canonicalize_type_argument          (tree, tsubst_flags_t);
    7025                 :            : extern void register_local_specialization       (tree, tree);
    7026                 :            : extern tree retrieve_local_specialization       (tree);
    7027                 :            : extern tree extract_fnparm_pack                 (tree, tree *);
    7028                 :            : extern tree template_parm_to_arg                (tree);
    7029                 :            : extern tree dguide_name                         (tree);
    7030                 :            : extern bool dguide_name_p                       (tree);
    7031                 :            : extern bool deduction_guide_p                   (const_tree);
    7032                 :            : extern bool copy_guide_p                        (const_tree);
    7033                 :            : extern bool template_guide_p                    (const_tree);
    7034                 :            : extern void store_explicit_specifier            (tree, tree);
    7035                 :            : extern tree add_outermost_template_args         (tree, tree);
    7036                 :            : 
    7037                 :            : /* in rtti.c */
    7038                 :            : /* A vector of all tinfo decls that haven't been emitted yet.  */
    7039                 :            : extern GTY(()) vec<tree, va_gc> *unemitted_tinfo_decls;
    7040                 :            : 
    7041                 :            : extern void init_rtti_processing                (void);
    7042                 :            : extern tree build_typeid                        (tree, tsubst_flags_t);
    7043                 :            : extern tree get_tinfo_decl                      (tree);
    7044                 :            : extern tree get_typeid                          (tree, tsubst_flags_t);
    7045                 :            : extern tree build_headof                        (tree);
    7046                 :            : extern tree build_dynamic_cast                  (location_t, tree, tree,
    7047                 :            :                                                  tsubst_flags_t);
    7048                 :            : extern void emit_support_tinfos                 (void);
    7049                 :            : extern bool emit_tinfo_decl                     (tree);
    7050                 :            : 
    7051                 :            : /* in search.c */
    7052                 :            : extern bool accessible_base_p                   (tree, tree, bool);
    7053                 :            : extern tree lookup_base                         (tree, tree, base_access,
    7054                 :            :                                                  base_kind *, tsubst_flags_t);
    7055                 :            : extern tree dcast_base_hint                     (tree, tree);
    7056                 :            : extern int accessible_p                         (tree, tree, bool);
    7057                 :            : extern int accessible_in_template_p             (tree, tree);
    7058                 :            : extern tree lookup_field                        (tree, tree, int, bool);
    7059                 :            : extern tree lookup_fnfields                     (tree, tree, int);
    7060                 :            : extern tree lookup_member                       (tree, tree, int, bool,
    7061                 :            :                                                  tsubst_flags_t,
    7062                 :            :                                                  access_failure_info *afi = NULL);
    7063                 :            : extern tree lookup_member_fuzzy         (tree, tree, bool);
    7064                 :            : extern tree locate_field_accessor               (tree, tree, bool);
    7065                 :            : extern int look_for_overrides                   (tree, tree);
    7066                 :            : extern void get_pure_virtuals                   (tree);
    7067                 :            : extern void maybe_suppress_debug_info           (tree);
    7068                 :            : extern void note_debug_info_needed              (tree);
    7069                 :            : extern tree current_scope                       (void);
    7070                 :            : extern int at_function_scope_p                  (void);
    7071                 :            : extern bool at_class_scope_p                    (void);
    7072                 :            : extern bool at_namespace_scope_p                (void);
    7073                 :            : extern tree context_for_name_lookup             (tree);
    7074                 :            : extern tree lookup_conversions                  (tree);
    7075                 :            : extern tree binfo_from_vbase                    (tree);
    7076                 :            : extern tree binfo_for_vbase                     (tree, tree);
    7077                 :            : extern tree look_for_overrides_here             (tree, tree);
    7078                 :            : #define dfs_skip_bases ((tree)1)
    7079                 :            : extern tree dfs_walk_all (tree, tree (*) (tree, void *),
    7080                 :            :                           tree (*) (tree, void *), void *);
    7081                 :            : extern tree dfs_walk_once (tree, tree (*) (tree, void *),
    7082                 :            :                            tree (*) (tree, void *), void *);
    7083                 :            : extern tree binfo_via_virtual                   (tree, tree);
    7084                 :            : extern bool binfo_direct_p                      (tree);
    7085                 :            : extern tree build_baselink                      (tree, tree, tree, tree);
    7086                 :            : extern tree adjust_result_of_qualified_name_lookup
    7087                 :            :                                                 (tree, tree, tree);
    7088                 :            : extern tree copied_binfo                        (tree, tree);
    7089                 :            : extern tree original_binfo                      (tree, tree);
    7090                 :            : extern int shared_member_p                      (tree);
    7091                 :            : extern bool any_dependent_bases_p (tree = current_nonlambda_class_type ());
    7092                 :            : extern bool maybe_check_overriding_exception_spec (tree, tree);
    7093                 :            : 
    7094                 :            : /* The representation of a deferred access check.  */
    7095                 :            : 
    7096                 :            : struct GTY(()) deferred_access_check {
    7097                 :            :   /* The base class in which the declaration is referenced. */
    7098                 :            :   tree binfo;
    7099                 :            :   /* The declaration whose access must be checked.  */
    7100                 :            :   tree decl;
    7101                 :            :   /* The declaration that should be used in the error message.  */
    7102                 :            :   tree diag_decl;
    7103                 :            :   /* The location of this access.  */
    7104                 :            :   location_t loc;
    7105                 :            : };
    7106                 :            : 
    7107                 :            : /* in semantics.c */
    7108                 :            : extern void push_deferring_access_checks        (deferring_kind);
    7109                 :            : extern void resume_deferring_access_checks      (void);
    7110                 :            : extern void stop_deferring_access_checks        (void);
    7111                 :            : extern void pop_deferring_access_checks         (void);
    7112                 :            : extern vec<deferred_access_check, va_gc> *get_deferred_access_checks (void);
    7113                 :            : extern void reopen_deferring_access_checks (vec<deferred_access_check, va_gc> *);
    7114                 :            : extern void pop_to_parent_deferring_access_checks (void);
    7115                 :            : extern bool perform_access_checks (vec<deferred_access_check, va_gc> *,
    7116                 :            :                                    tsubst_flags_t);
    7117                 :            : extern bool perform_deferred_access_checks      (tsubst_flags_t);
    7118                 :            : extern bool perform_or_defer_access_check       (tree, tree, tree,
    7119                 :            :                                                  tsubst_flags_t,
    7120                 :            :                                                  access_failure_info *afi = NULL);
    7121                 :            : 
    7122                 :            : /* RAII sentinel to ensures that deferred access checks are popped before
    7123                 :            :   a function returns.  */
    7124                 :            : 
    7125                 :            : class deferring_access_check_sentinel
    7126                 :            : {
    7127                 :            : public:
    7128                 :   12964375 :   deferring_access_check_sentinel (enum deferring_kind kind = dk_deferred)
    7129                 :            :   {
    7130                 :   12964375 :     push_deferring_access_checks (kind);
    7131                 :            :   }
    7132                 :   12957975 :   ~deferring_access_check_sentinel ()
    7133                 :            :   {
    7134                 :   12957975 :     pop_deferring_access_checks ();
    7135                 :   10267900 :   }
    7136                 :            : };
    7137                 :            : 
    7138                 :            : extern int stmts_are_full_exprs_p               (void);
    7139                 :            : extern void init_cp_semantics                   (void);
    7140                 :            : extern tree do_poplevel                         (tree);
    7141                 :            : extern void break_maybe_infinite_loop           (void);
    7142                 :            : extern void add_decl_expr                       (tree);
    7143                 :            : extern tree maybe_cleanup_point_expr_void       (tree);
    7144                 :            : extern tree finish_expr_stmt                    (tree);
    7145                 :            : extern tree begin_if_stmt                       (void);
    7146                 :            : extern tree finish_if_stmt_cond                 (tree, tree);
    7147                 :            : extern tree finish_then_clause                  (tree);
    7148                 :            : extern void begin_else_clause                   (tree);
    7149                 :            : extern void finish_else_clause                  (tree);
    7150                 :            : extern void finish_if_stmt                      (tree);
    7151                 :            : extern tree begin_while_stmt                    (void);
    7152                 :            : extern void finish_while_stmt_cond      (tree, tree, bool, unsigned short);
    7153                 :            : extern void finish_while_stmt                   (tree);
    7154                 :            : extern tree begin_do_stmt                       (void);
    7155                 :            : extern void finish_do_body                      (tree);
    7156                 :            : extern void finish_do_stmt              (tree, tree, bool, unsigned short);
    7157                 :            : extern tree finish_return_stmt                  (tree);
    7158                 :            : extern tree begin_for_scope                     (tree *);
    7159                 :            : extern tree begin_for_stmt                      (tree, tree);
    7160                 :            : extern void finish_init_stmt                    (tree);
    7161                 :            : extern void finish_for_cond             (tree, tree, bool, unsigned short);
    7162                 :            : extern void finish_for_expr                     (tree, tree);
    7163                 :            : extern void finish_for_stmt                     (tree);
    7164                 :            : extern tree begin_range_for_stmt                (tree, tree);
    7165                 :            : extern void finish_range_for_decl               (tree, tree, tree);
    7166                 :            : extern void finish_range_for_stmt               (tree);
    7167                 :            : extern tree finish_break_stmt                   (void);
    7168                 :            : extern tree finish_continue_stmt                (void);
    7169                 :            : extern tree begin_switch_stmt                   (void);
    7170                 :            : extern void finish_switch_cond                  (tree, tree);
    7171                 :            : extern void finish_switch_stmt                  (tree);
    7172                 :            : extern tree finish_goto_stmt                    (tree);
    7173                 :            : extern tree begin_try_block                     (void);
    7174                 :            : extern void finish_try_block                    (tree);
    7175                 :            : extern void finish_handler_sequence             (tree);
    7176                 :            : extern tree begin_function_try_block            (tree *);
    7177                 :            : extern void finish_function_try_block           (tree);
    7178                 :            : extern void finish_function_handler_sequence    (tree, tree);
    7179                 :            : extern void finish_cleanup_try_block            (tree);
    7180                 :            : extern tree begin_handler                       (void);
    7181                 :            : extern void finish_handler_parms                (tree, tree);
    7182                 :            : extern void finish_handler                      (tree);
    7183                 :            : extern void finish_cleanup                      (tree, tree);
    7184                 :            : extern bool is_this_parameter                   (tree);
    7185                 :            : 
    7186                 :            : enum {
    7187                 :            :   BCS_NORMAL = 0,
    7188                 :            :   BCS_NO_SCOPE = 1,
    7189                 :            :   BCS_TRY_BLOCK = 2,
    7190                 :            :   BCS_FN_BODY = 4,
    7191                 :            :   BCS_TRANSACTION = 8
    7192                 :            : };
    7193                 :            : extern tree begin_compound_stmt                 (unsigned int);
    7194                 :            : 
    7195                 :            : extern void finish_compound_stmt                (tree);
    7196                 :            : extern tree finish_asm_stmt                     (location_t, int, tree, tree,
    7197                 :            :                                                  tree, tree, tree, bool);
    7198                 :            : extern tree finish_label_stmt                   (tree);
    7199                 :            : extern void finish_label_decl                   (tree);
    7200                 :            : extern cp_expr finish_parenthesized_expr        (cp_expr);
    7201                 :            : extern tree force_paren_expr                    (tree, bool = false);
    7202                 :     803085 : inline tree force_paren_expr_uneval             (tree t)
    7203                 :     803085 : { return force_paren_expr (t, true); }
    7204                 :            : extern tree maybe_undo_parenthesized_ref        (tree);
    7205                 :            : extern tree maybe_strip_ref_conversion          (tree);
    7206                 :            : extern tree finish_non_static_data_member       (tree, tree, tree);
    7207                 :            : extern tree begin_stmt_expr                     (void);
    7208                 :            : extern tree finish_stmt_expr_expr               (tree, tree);
    7209                 :            : extern tree finish_stmt_expr                    (tree, bool);
    7210                 :            : extern tree stmt_expr_value_expr                (tree);
    7211                 :            : bool empty_expr_stmt_p                          (tree);
    7212                 :            : extern cp_expr perform_koenig_lookup            (cp_expr, vec<tree, va_gc> *,
    7213                 :            :                                                  tsubst_flags_t);
    7214                 :            : extern tree finish_call_expr                    (tree, vec<tree, va_gc> **, bool,
    7215                 :            :                                                  bool, tsubst_flags_t);
    7216                 :            : extern tree lookup_and_finish_template_variable (tree, tree, tsubst_flags_t = tf_warning_or_error);
    7217                 :            : extern tree finish_template_variable            (tree, tsubst_flags_t = tf_warning_or_error);
    7218                 :            : extern cp_expr finish_increment_expr            (cp_expr, enum tree_code);
    7219                 :            : extern tree finish_this_expr                    (void);
    7220                 :            : extern tree finish_pseudo_destructor_expr       (tree, tree, tree, location_t);
    7221                 :            : extern cp_expr finish_unary_op_expr             (location_t, enum tree_code, cp_expr,
    7222                 :            :                                                  tsubst_flags_t);
    7223                 :            : /* Whether this call to finish_compound_literal represents a C++11 functional
    7224                 :            :    cast or a C99 compound literal.  */
    7225                 :            : enum fcl_t { fcl_functional, fcl_c99 };
    7226                 :            : extern tree finish_compound_literal             (tree, tree, tsubst_flags_t, fcl_t = fcl_functional);
    7227                 :            : extern tree finish_fname                        (tree);
    7228                 :            : extern void finish_translation_unit             (void);
    7229                 :            : extern tree finish_template_type_parm           (tree, tree);
    7230                 :            : extern tree finish_template_template_parm       (tree, tree);
    7231                 :            : extern tree begin_class_definition              (tree);
    7232                 :            : extern void finish_template_decl                (tree);
    7233                 :            : extern tree finish_template_type                (tree, tree, int);
    7234                 :            : extern tree finish_base_specifier               (tree, tree, bool);
    7235                 :            : extern void finish_member_declaration           (tree);
    7236                 :            : extern bool outer_automatic_var_p               (tree);
    7237                 :            : extern tree process_outer_var_ref               (tree, tsubst_flags_t, bool force_use = false);
    7238                 :            : extern cp_expr finish_id_expression             (tree, tree, tree,
    7239                 :            :                                                  cp_id_kind *,
    7240                 :            :                                                  bool, bool, bool *,
    7241                 :            :                                                  bool, bool, bool, bool,
    7242                 :            :                                                  const char **,
    7243                 :            :                                                  location_t);
    7244                 :            : extern tree finish_typeof                       (tree);
    7245                 :            : extern tree finish_underlying_type              (tree);
    7246                 :            : extern tree calculate_bases                     (tree, tsubst_flags_t);
    7247                 :            : extern tree finish_bases                        (tree, bool);
    7248                 :            : extern tree calculate_direct_bases              (tree, tsubst_flags_t);
    7249                 :            : extern tree finish_offsetof                     (tree, tree, location_t);
    7250                 :            : extern void finish_decl_cleanup                 (tree, tree);
    7251                 :            : extern void finish_eh_cleanup                   (tree);
    7252                 :            : extern void emit_associated_thunks              (tree);
    7253                 :            : extern void finish_mem_initializers             (tree);
    7254                 :            : extern tree check_template_template_default_arg (tree);
    7255                 :            : extern bool expand_or_defer_fn_1                (tree);
    7256                 :            : extern void expand_or_defer_fn                  (tree);
    7257                 :            : extern void add_typedef_to_current_template_for_access_check (tree, tree,
    7258                 :            :                                                               location_t);
    7259                 :            : extern void check_accessibility_of_qualified_id (tree, tree, tree);
    7260                 :            : extern tree finish_qualified_id_expr            (tree, tree, bool, bool,
    7261                 :            :                                                  bool, bool, tsubst_flags_t);
    7262                 :            : extern void simplify_aggr_init_expr             (tree *);
    7263                 :            : extern void finalize_nrv                        (tree *, tree, tree);
    7264                 :            : extern tree omp_reduction_id                    (enum tree_code, tree, tree);
    7265                 :            : extern tree cp_remove_omp_priv_cleanup_stmt     (tree *, int *, void *);
    7266                 :            : extern void cp_check_omp_declare_reduction      (tree);
    7267                 :            : extern void finish_omp_declare_simd_methods     (tree);
    7268                 :            : extern tree finish_omp_clauses                  (tree, enum c_omp_region_type);
    7269                 :            : extern tree push_omp_privatization_clauses      (bool);
    7270                 :            : extern void pop_omp_privatization_clauses       (tree);
    7271                 :            : extern void save_omp_privatization_clauses      (vec<tree> &);
    7272                 :            : extern void restore_omp_privatization_clauses   (vec<tree> &);
    7273                 :            : extern void finish_omp_threadprivate            (tree);
    7274                 :            : extern tree begin_omp_structured_block          (void);
    7275                 :            : extern tree finish_omp_structured_block         (tree);
    7276                 :            : extern tree finish_oacc_data                    (tree, tree);
    7277                 :            : extern tree finish_oacc_host_data               (tree, tree);
    7278                 :            : extern tree finish_omp_construct                (enum tree_code, tree, tree);
    7279                 :            : extern tree begin_omp_parallel                  (void);
    7280                 :            : extern tree finish_omp_parallel                 (tree, tree);
    7281                 :            : extern tree begin_omp_task                      (void);
    7282                 :            : extern tree finish_omp_task                     (tree, tree);
    7283                 :            : extern tree finish_omp_for                      (location_t, enum tree_code,
    7284                 :            :                                                  tree, tree, tree, tree, tree,
    7285                 :            :                                                  tree, tree, vec<tree> *, tree);
    7286                 :            : extern tree finish_omp_for_block                (tree, tree);
    7287                 :            : extern void finish_omp_atomic                   (location_t, enum tree_code,
    7288                 :            :                                                  enum tree_code, tree, tree,
    7289                 :            :                                                  tree, tree, tree, tree,
    7290                 :            :                                                  enum omp_memory_order);
    7291                 :            : extern void finish_omp_barrier                  (void);
    7292                 :            : extern void finish_omp_depobj                   (location_t, tree,
    7293                 :            :                                                  enum omp_clause_depend_kind,
    7294                 :            :                                                  tree);
    7295                 :            : extern void finish_omp_flush                    (int);
    7296                 :            : extern void finish_omp_taskwait                 (void);
    7297                 :            : extern void finish_omp_taskyield                (void);
    7298                 :            : extern void finish_omp_cancel                   (tree);
    7299                 :            : extern void finish_omp_cancellation_point       (tree);
    7300                 :            : extern tree omp_privatize_field                 (tree, bool);
    7301                 :            : extern tree begin_transaction_stmt              (location_t, tree *, int);
    7302                 :            : extern void finish_transaction_stmt             (tree, tree, int, tree);
    7303                 :            : extern tree build_transaction_expr              (location_t, tree, int, tree);
    7304                 :            : extern bool cxx_omp_create_clause_info          (tree, tree, bool, bool,
    7305                 :            :                                                  bool, bool);
    7306                 :            : extern tree baselink_for_fns                    (tree);
    7307                 :            : extern void finish_static_assert                (tree, tree, location_t,
    7308                 :            :                                                  bool);
    7309                 :            : extern tree finish_decltype_type                (tree, bool, tsubst_flags_t);
    7310                 :            : extern tree finish_trait_expr                   (location_t, enum cp_trait_kind, tree, tree);
    7311                 :            : extern tree build_lambda_expr                   (void);
    7312                 :            : extern tree build_lambda_object                 (tree);
    7313                 :            : extern tree begin_lambda_type                   (tree);
    7314                 :            : extern tree lambda_capture_field_type           (tree, bool, bool);
    7315                 :            : extern tree lambda_return_type                  (tree);
    7316                 :            : extern tree lambda_proxy_type                   (tree);
    7317                 :            : extern tree lambda_function                     (tree);
    7318                 :            : extern void apply_deduced_return_type           (tree, tree);
    7319                 :            : extern tree add_capture                         (tree, tree, tree, bool, bool);
    7320                 :            : extern tree add_default_capture                 (tree, tree, tree);
    7321                 :            : extern void insert_capture_proxy                (tree);
    7322                 :            : extern void insert_pending_capture_proxies      (void);
    7323                 :            : extern bool is_capture_proxy                    (tree);
    7324                 :            : extern bool is_normal_capture_proxy             (tree);
    7325                 :            : extern bool is_constant_capture_proxy           (tree);
    7326                 :            : extern void register_capture_members            (tree);
    7327                 :            : extern tree lambda_expr_this_capture            (tree, int);
    7328                 :            : extern void maybe_generic_this_capture          (tree, tree);
    7329                 :            : extern tree maybe_resolve_dummy                 (tree, bool);
    7330                 :            : extern tree current_nonlambda_function          (void);
    7331                 :            : extern tree nonlambda_method_basetype           (void);
    7332                 :            : extern tree current_nonlambda_scope             (void);
    7333                 :            : extern tree current_lambda_expr                 (void);
    7334                 :            : extern bool generic_lambda_fn_p                 (tree);
    7335                 :            : extern tree do_dependent_capture                (tree, bool = false);
    7336                 :            : extern bool lambda_fn_in_template_p             (tree);
    7337                 :            : extern void maybe_add_lambda_conv_op            (tree);
    7338                 :            : extern bool is_lambda_ignored_entity            (tree);
    7339                 :            : extern bool lambda_static_thunk_p               (tree);
    7340                 :            : extern tree finish_builtin_launder              (location_t, tree,
    7341                 :            :                                                  tsubst_flags_t);
    7342                 :            : extern tree cp_build_vec_convert                (tree, location_t, tree,
    7343                 :            :                                                  tsubst_flags_t);
    7344                 :            : extern void start_lambda_scope                  (tree);
    7345                 :            : extern void record_lambda_scope                 (tree);
    7346                 :            : extern void record_null_lambda_scope            (tree);
    7347                 :            : extern void finish_lambda_scope                 (void);
    7348                 :            : extern tree start_lambda_function               (tree fn, tree lambda_expr);
    7349                 :            : extern void finish_lambda_function              (tree body);
    7350                 :            : 
    7351                 :            : /* in tree.c */
    7352                 :            : extern int cp_tree_operand_length               (const_tree);
    7353                 :            : extern int cp_tree_code_length                  (enum tree_code);
    7354                 :            : extern void cp_free_lang_data                   (tree t);
    7355                 :            : extern tree force_target_expr                   (tree, tree, tsubst_flags_t);
    7356                 :            : extern tree build_target_expr_with_type         (tree, tree, tsubst_flags_t);
    7357                 :            : extern void lang_check_failed                   (const char *, int,
    7358                 :            :                                                  const char *) ATTRIBUTE_NORETURN
    7359                 :            :                                                  ATTRIBUTE_COLD;
    7360                 :            : extern tree stabilize_expr                      (tree, tree *);
    7361                 :            : extern void stabilize_call                      (tree, tree *);
    7362                 :            : extern bool stabilize_init                      (tree, tree *);
    7363                 :            : extern tree add_stmt_to_compound                (tree, tree);
    7364                 :            : extern void init_tree                           (void);
    7365                 :            : extern bool pod_type_p                          (const_tree);
    7366                 :            : extern bool layout_pod_type_p                   (const_tree);
    7367                 :            : extern bool std_layout_type_p                   (const_tree);
    7368                 :            : extern bool trivial_type_p                      (const_tree);
    7369                 :            : extern bool trivially_copyable_p                (const_tree);
    7370                 :            : extern bool type_has_unique_obj_representations (const_tree);
    7371                 :            : extern bool scalarish_type_p                    (const_tree);
    7372                 :            : extern bool structural_type_p                   (tree, bool = false);
    7373                 :            : extern bool type_has_nontrivial_default_init    (const_tree);
    7374                 :            : extern bool type_has_nontrivial_copy_init       (const_tree);
    7375                 :            : extern void maybe_warn_parm_abi                 (tree, location_t);
    7376                 :            : extern bool class_tmpl_impl_spec_p              (const_tree);
    7377                 :            : extern int zero_init_p                          (const_tree);
    7378                 :            : extern bool check_abi_tag_redeclaration         (const_tree, const_tree,
    7379                 :            :                                                  const_tree);
    7380                 :            : extern bool check_abi_tag_args                  (tree, tree);
    7381                 :            : extern tree strip_typedefs                      (tree, bool * = NULL,
    7382                 :            :                                                  unsigned int = 0);
    7383                 :            : extern tree strip_typedefs_expr                 (tree, bool * = NULL,
    7384                 :            :                                                  unsigned int = 0);
    7385                 :            : extern tree copy_binfo                          (tree, tree, tree,
    7386                 :            :                                                  tree *, int);
    7387                 :            : extern int member_p                             (const_tree);
    7388                 :            : extern cp_lvalue_kind real_lvalue_p             (const_tree);
    7389                 :            : extern cp_lvalue_kind lvalue_kind               (const_tree);
    7390                 :            : extern bool glvalue_p                           (const_tree);
    7391                 :            : extern bool obvalue_p                           (const_tree);
    7392                 :            : extern bool xvalue_p                            (const_tree);
    7393                 :            : extern bool bitfield_p                          (const_tree);
    7394                 :            : extern tree cp_stabilize_reference              (tree);
    7395                 :            : extern bool builtin_valid_in_constant_expr_p    (const_tree);
    7396                 :            : extern tree build_min                           (enum tree_code, tree, ...);
    7397                 :            : extern tree build_min_nt_loc                    (location_t, enum tree_code,
    7398                 :            :                                                  ...);
    7399                 :            : extern tree build_min_non_dep                   (enum tree_code, tree, ...);
    7400                 :            : extern tree build_min_non_dep_op_overload       (enum tree_code, tree, tree, ...);
    7401                 :            : extern tree build_min_nt_call_vec (tree, vec<tree, va_gc> *);
    7402                 :            : extern tree build_min_non_dep_call_vec          (tree, tree, vec<tree, va_gc> *);
    7403                 :            : extern vec<tree, va_gc>* vec_copy_and_insert    (vec<tree, va_gc>*, tree, unsigned);
    7404                 :            : extern tree build_cplus_new                     (tree, tree, tsubst_flags_t);
    7405                 :            : extern tree build_local_temp                    (tree);
    7406                 :            : extern bool is_local_temp                       (tree);
    7407                 :            : extern tree build_aggr_init_expr                (tree, tree);
    7408                 :            : extern tree get_target_expr                     (tree);
    7409                 :            : extern tree get_target_expr_sfinae              (tree, tsubst_flags_t);
    7410                 :            : extern tree build_cplus_array_type              (tree, tree);
    7411                 :            : extern tree build_array_of_n_type               (tree, int);
    7412                 :            : extern bool array_of_runtime_bound_p            (tree);
    7413                 :            : extern bool vla_type_p                          (tree);
    7414                 :            : extern tree build_array_copy                    (tree);
    7415                 :            : extern tree build_vec_init_expr                 (tree, tree, tsubst_flags_t);
    7416                 :            : extern void diagnose_non_constexpr_vec_init     (tree);
    7417                 :            : extern tree hash_tree_cons                      (tree, tree, tree);
    7418                 :            : extern tree hash_tree_chain                     (tree, tree);
    7419                 :            : extern tree build_qualified_name                (tree, tree, tree, bool);
    7420                 :            : extern tree build_ref_qualified_type            (tree, cp_ref_qualifier);
    7421                 :            : inline tree ovl_first                           (tree) ATTRIBUTE_PURE;
    7422                 :            : extern tree ovl_make                            (tree fn,
    7423                 :            :                                                  tree next = NULL_TREE);
    7424                 :            : extern tree ovl_insert                          (tree fn, tree maybe_ovl,
    7425                 :            :                                                  bool using_p = false);
    7426                 :            : extern tree ovl_skip_hidden                     (tree) ATTRIBUTE_PURE;
    7427                 :            : extern void lookup_mark                         (tree lookup, bool val);
    7428                 :            : extern tree lookup_add                          (tree fns, tree lookup);
    7429                 :            : extern tree lookup_maybe_add                    (tree fns, tree lookup,
    7430                 :            :                                                  bool deduping);
    7431                 :            : extern int is_overloaded_fn                     (tree) ATTRIBUTE_PURE;
    7432                 :            : extern bool really_overloaded_fn                (tree) ATTRIBUTE_PURE;
    7433                 :            : extern tree dependent_name                      (tree);
    7434                 :            : extern tree maybe_get_fns                       (tree) ATTRIBUTE_PURE;
    7435                 :            : extern tree get_fns                             (tree) ATTRIBUTE_PURE;
    7436                 :            : extern tree get_first_fn                        (tree) ATTRIBUTE_PURE;
    7437                 :            : extern tree ovl_scope                           (tree);
    7438                 :            : extern const char *cxx_printable_name           (tree, int);
    7439                 :            : extern const char *cxx_printable_name_translate (tree, int);
    7440                 :            : extern tree canonical_eh_spec                   (tree);
    7441                 :            : extern tree build_cp_fntype_variant             (tree, cp_ref_qualifier, tree, bool);
    7442                 :            : extern tree build_exception_variant             (tree, tree);
    7443                 :            : extern tree bind_template_template_parm         (tree, tree);
    7444                 :            : extern tree array_type_nelts_total              (tree);
    7445                 :            : extern tree array_type_nelts_top                (tree);
    7446                 :            : extern bool array_of_unknown_bound_p            (const_tree);
    7447                 :            : extern tree break_out_target_exprs              (tree, bool = false);
    7448                 :            : extern tree build_ctor_subob_ref                (tree, tree, tree);
    7449                 :            : extern tree replace_placeholders                (tree, tree, bool * = NULL);
    7450                 :            : extern bool find_placeholders                   (tree);
    7451                 :            : extern tree get_type_decl                       (tree);
    7452                 :            : extern tree decl_namespace_context              (tree);
    7453                 :            : extern bool decl_anon_ns_mem_p                  (const_tree);
    7454                 :            : extern tree lvalue_type                         (tree);
    7455                 :            : extern tree error_type                          (tree);
    7456                 :            : extern int varargs_function_p                   (const_tree);
    7457                 :            : extern bool cp_tree_equal                       (tree, tree);
    7458                 :            : extern tree no_linkage_check                    (tree, bool);
    7459                 :            : extern void debug_binfo                         (tree);
    7460                 :            : extern tree build_dummy_object                  (tree);
    7461                 :            : extern tree maybe_dummy_object                  (tree, tree *);
    7462                 :            : extern int is_dummy_object                      (const_tree);
    7463                 :            : extern const struct attribute_spec cxx_attribute_table[];
    7464                 :            : extern tree make_ptrmem_cst                     (tree, tree);
    7465                 :            : extern tree cp_build_type_attribute_variant     (tree, tree);
    7466                 :            : extern tree cp_build_reference_type             (tree, bool);
    7467                 :            : extern tree move                                (tree);
    7468                 :            : extern tree cp_build_qualified_type_real        (tree, int, tsubst_flags_t);
    7469                 :            : #define cp_build_qualified_type(TYPE, QUALS) \
    7470                 :            :   cp_build_qualified_type_real ((TYPE), (QUALS), tf_warning_or_error)
    7471                 :            : extern bool cv_qualified_p                      (const_tree);
    7472                 :            : extern tree cv_unqualified                      (tree);
    7473                 :            : extern special_function_kind special_function_p (const_tree);
    7474                 :            : extern special_function_kind special_memfn_p    (const_tree);
    7475                 :            : extern int count_trees                          (tree);
    7476                 :            : extern int char_type_p                          (tree);
    7477                 :            : extern void verify_stmt_tree                    (tree);
    7478                 :            : extern linkage_kind decl_linkage                (tree);
    7479                 :            : extern duration_kind decl_storage_duration      (tree);
    7480                 :            : extern tree cp_walk_subtrees (tree*, int*, walk_tree_fn,
    7481                 :            :                               void*, hash_set<tree> *);
    7482                 :            : #define cp_walk_tree(tp,func,data,pset) \
    7483                 :            :         walk_tree_1 (tp, func, data, pset, cp_walk_subtrees)
    7484                 :            : #define cp_walk_tree_without_duplicates(tp,func,data) \
    7485                 :            :         walk_tree_without_duplicates_1 (tp, func, data, cp_walk_subtrees)
    7486                 :            : extern tree rvalue                              (tree);
    7487                 :            : extern tree convert_bitfield_to_declared_type   (tree);
    7488                 :            : extern tree cp_save_expr                        (tree);
    7489                 :            : extern bool cast_valid_in_integral_constant_expression_p (tree);
    7490                 :            : extern bool cxx_type_hash_eq                    (const_tree, const_tree);
    7491                 :            : extern tree cxx_copy_lang_qualifiers            (const_tree, const_tree);
    7492                 :            : 
    7493                 :            : extern void cxx_print_statistics                (void);
    7494                 :            : extern bool maybe_warn_zero_as_null_pointer_constant (tree, location_t);
    7495                 :            : /* Analogous to initializer_zerop but also examines the type for
    7496                 :            :    which the initializer is being used.  Unlike initializer_zerop,
    7497                 :            :    considers empty strings to be zero initializers for arrays and
    7498                 :            :    non-zero for pointers.  */
    7499                 :            : extern bool type_initializer_zero_p             (tree, tree);
    7500                 :            : 
    7501                 :            : /* in ptree.c */
    7502                 :            : extern void cxx_print_xnode                     (FILE *, tree, int);
    7503                 :            : extern void cxx_print_decl                      (FILE *, tree, int);
    7504                 :            : extern void cxx_print_type                      (FILE *, tree, int);
    7505                 :            : extern void cxx_print_identifier                (FILE *, tree, int);
    7506                 :            : extern void cxx_print_error_function            (diagnostic_context *,
    7507                 :            :                                                  const char *,
    7508                 :            :                                                  struct diagnostic_info *);
    7509                 :            : 
    7510                 :            : /* in typeck.c */
    7511                 :            : /* Says how we should behave when comparing two arrays one of which
    7512                 :            :    has unknown bounds.  */
    7513                 :            : enum compare_bounds_t { bounds_none, bounds_either, bounds_first };
    7514                 :            : 
    7515                 :            : extern bool cxx_mark_addressable                (tree, bool = false);
    7516                 :            : extern int string_conv_p                        (const_tree, const_tree, int);
    7517                 :            : extern tree cp_truthvalue_conversion            (tree, tsubst_flags_t);
    7518                 :            : extern tree contextual_conv_bool                (tree, tsubst_flags_t);
    7519                 :            : extern tree condition_conversion                (tree);
    7520                 :            : extern tree require_complete_type               (tree);
    7521                 :            : extern tree require_complete_type_sfinae        (tree, tsubst_flags_t);
    7522                 :            : extern tree complete_type                       (tree);
    7523                 :            : extern tree complete_type_or_else               (tree, tree);
    7524                 :            : extern tree complete_type_or_maybe_complain     (tree, tree, tsubst_flags_t);
    7525                 :            : inline bool type_unknown_p                      (const_tree);
    7526                 :            : enum { ce_derived, ce_type, ce_normal, ce_exact };
    7527                 :            : extern bool comp_except_specs                   (const_tree, const_tree, int);
    7528                 :            : extern bool comptypes                           (tree, tree, int);
    7529                 :            : extern bool same_type_ignoring_top_level_qualifiers_p (tree, tree);
    7530                 :            : extern bool similar_type_p                      (tree, tree);
    7531                 :            : extern bool compparms                           (const_tree, const_tree);
    7532                 :            : extern int comp_cv_qualification                (const_tree, const_tree);
    7533                 :            : extern int comp_cv_qualification                (int, int);
    7534                 :            : extern int comp_cv_qual_signature               (tree, tree);
    7535                 :            : extern tree cxx_sizeof_or_alignof_expr          (location_t, tree,
    7536                 :            :                                                  enum tree_code, bool);
    7537                 :            : extern tree cxx_sizeof_or_alignof_type          (location_t, tree,
    7538                 :            :                                                  enum tree_code, bool, bool);
    7539                 :            : extern tree cxx_alignas_expr                    (tree);
    7540                 :            : extern tree cxx_sizeof_nowarn                   (tree);
    7541                 :            : extern tree is_bitfield_expr_with_lowered_type  (const_tree);
    7542                 :            : extern tree unlowered_expr_type                 (const_tree);
    7543                 :            : extern tree decay_conversion                    (tree,
    7544                 :            :                                                  tsubst_flags_t,
    7545                 :            :                                                  bool = true);
    7546                 :            : extern tree build_class_member_access_expr      (cp_expr, tree, tree, bool,
    7547                 :            :                                                  tsubst_flags_t);
    7548                 :            : extern tree finish_class_member_access_expr     (cp_expr, tree, bool,
    7549                 :            :                                                  tsubst_flags_t);
    7550                 :            : extern tree lookup_destructor                   (tree, tree, tree, tsubst_flags_t);
    7551                 :            : extern tree build_x_indirect_ref                (location_t, tree,
    7552                 :            :                                                  ref_operator,
    7553                 :            :                                                  tsubst_flags_t);
    7554                 :            : extern tree cp_build_indirect_ref               (location_t, tree,
    7555                 :            :                                                  ref_operator,
    7556                 :            :                                                  tsubst_flags_t);
    7557                 :            : extern tree cp_build_fold_indirect_ref          (tree);
    7558                 :            : extern tree build_array_ref                     (location_t, tree, tree);
    7559                 :            : extern tree cp_build_array_ref                  (location_t, tree, tree,
    7560                 :            :                                                  tsubst_flags_t);
    7561                 :            : extern tree get_member_function_from_ptrfunc    (tree *, tree, tsubst_flags_t);
    7562                 :            : extern tree cp_build_function_call_nary         (tree, tsubst_flags_t, ...)
    7563                 :            :                                                 ATTRIBUTE_SENTINEL;
    7564                 :            : extern tree cp_build_function_call_vec          (tree, vec<tree, va_gc> **,
    7565                 :            :                                                  tsubst_flags_t,
    7566                 :            :                                                  tree = NULL_TREE);
    7567                 :            : extern tree build_x_binary_op                   (const op_location_t &,
    7568                 :            :                                                  enum tree_code, tree,
    7569                 :            :                                                  enum tree_code, tree,
    7570                 :            :                                                  enum tree_code, tree *,
    7571                 :            :                                                  tsubst_flags_t);
    7572                 :            : inline tree build_x_binary_op (const op_location_t &loc,
    7573                 :            :                                enum tree_code code, tree arg1, tree arg2,
    7574                 :            :                                tsubst_flags_t complain)
    7575                 :            : {
    7576                 :            :   return build_x_binary_op (loc, code, arg1, TREE_CODE (arg1), arg2,
    7577                 :            :                             TREE_CODE (arg2), NULL, complain);
    7578                 :            : }
    7579                 :            : extern tree build_x_array_ref                   (location_t, tree, tree,
    7580                 :            :                                                  tsubst_flags_t);
    7581                 :            : extern tree build_x_unary_op                    (location_t,
    7582                 :            :                                                  enum tree_code, cp_expr,
    7583                 :            :                                                  tsubst_flags_t);
    7584                 :            : extern tree cp_build_addressof                  (location_t, tree,
    7585                 :            :                                                  tsubst_flags_t);
    7586                 :            : extern tree cp_build_addr_expr                  (tree, tsubst_flags_t);
    7587                 :            : extern tree cp_build_unary_op                   (enum tree_code, tree, bool,
    7588                 :            :                                                  tsubst_flags_t);
    7589                 :            : extern tree genericize_compound_lvalue          (tree);
    7590                 :            : extern tree unary_complex_lvalue                (enum tree_code, tree);
    7591                 :            : extern tree build_x_conditional_expr            (location_t, tree, tree, tree,
    7592                 :            :                                                  tsubst_flags_t);
    7593                 :            : extern tree build_x_compound_expr_from_list     (tree, expr_list_kind,
    7594                 :            :                                                  tsubst_flags_t);
    7595                 :            : extern tree build_x_compound_expr_from_vec      (vec<tree, va_gc> *,
    7596                 :            :                                                  const char *, tsubst_flags_t);
    7597                 :            : extern tree build_x_compound_expr               (location_t, tree, tree,
    7598                 :            :                                                  tsubst_flags_t);
    7599                 :            : extern tree build_compound_expr                 (location_t, tree, tree);
    7600                 :            : extern tree cp_build_compound_expr              (tree, tree, tsubst_flags_t);
    7601                 :            : extern tree build_static_cast                   (location_t, tree, tree,
    7602                 :            :                                                  tsubst_flags_t);
    7603                 :            : extern tree build_reinterpret_cast              (location_t, tree, tree,
    7604                 :            :                                                  tsubst_flags_t);
    7605                 :            : extern tree build_const_cast                    (location_t, tree, tree,
    7606                 :            :                                                  tsubst_flags_t);
    7607                 :            : extern tree build_c_cast                        (location_t, tree, tree);
    7608                 :            : extern cp_expr build_c_cast                     (location_t loc, tree type,
    7609                 :            :                                                  cp_expr expr);
    7610                 :            : extern tree cp_build_c_cast                     (location_t, tree, tree,
    7611                 :            :                                                  tsubst_flags_t);
    7612                 :            : extern cp_expr build_x_modify_expr              (location_t, tree,
    7613                 :            :                                                  enum tree_code, tree,
    7614                 :            :                                                  tsubst_flags_t);
    7615                 :            : extern tree cp_build_modify_expr                (location_t, tree,
    7616                 :            :                                                  enum tree_code, tree,
    7617                 :            :                                                  tsubst_flags_t);
    7618                 :            : extern tree convert_for_initialization          (tree, tree, tree, int,
    7619                 :            :                                                  impl_conv_rhs, tree, int,
    7620                 :            :                                                  tsubst_flags_t);
    7621                 :            : extern int comp_ptr_ttypes                      (tree, tree);
    7622                 :            : extern bool comp_ptr_ttypes_const               (tree, tree, compare_bounds_t);
    7623                 :            : extern bool error_type_p                        (const_tree);
    7624                 :            : extern bool ptr_reasonably_similar              (const_tree, const_tree);
    7625                 :            : extern tree build_ptrmemfunc                    (tree, tree, int, bool,
    7626                 :            :                                                  tsubst_flags_t);
    7627                 :            : extern int cp_type_quals                        (const_tree);
    7628                 :            : extern int type_memfn_quals                     (const_tree);
    7629                 :            : extern cp_ref_qualifier type_memfn_rqual        (const_tree);
    7630                 :            : extern tree apply_memfn_quals                   (tree, cp_cv_quals,
    7631                 :            :                                                  cp_ref_qualifier = REF_QUAL_NONE);
    7632                 :            : extern bool cp_has_mutable_p                    (const_tree);
    7633                 :            : extern bool at_least_as_qualified_p             (const_tree, const_tree);
    7634                 :            : extern void cp_apply_type_quals_to_decl         (int, tree);
    7635                 :            : extern tree build_ptrmemfunc1                   (tree, tree, tree);
    7636                 :            : extern void expand_ptrmemfunc_cst               (tree, tree *, tree *);
    7637                 :            : extern tree type_after_usual_arithmetic_conversions (tree, tree);
    7638                 :            : extern tree common_pointer_type                 (tree, tree);
    7639                 :            : extern tree composite_pointer_type              (const op_location_t &,
    7640                 :            :                                                  tree, tree, tree, tree,
    7641                 :            :                                                  composite_pointer_operation,
    7642                 :            :                                                  tsubst_flags_t);
    7643                 :            : extern tree merge_types                         (tree, tree);
    7644                 :            : extern tree strip_array_domain                  (tree);
    7645                 :            : extern tree check_return_expr                   (tree, bool *);
    7646                 :            : extern tree spaceship_type                      (tree, tsubst_flags_t = tf_warning_or_error);
    7647                 :            : extern tree genericize_spaceship                (tree, tree, tree);
    7648                 :            : extern tree cp_build_binary_op                  (const op_location_t &,
    7649                 :            :                                                  enum tree_code, tree, tree,
    7650                 :            :                                                  tsubst_flags_t);
    7651                 :            : extern tree build_x_vec_perm_expr               (location_t,
    7652                 :            :                                                  tree, tree, tree,
    7653                 :            :                                                  tsubst_flags_t);
    7654                 :            : #define cxx_sizeof(T)  cxx_sizeof_or_alignof_type (input_location, T, SIZEOF_EXPR, false, true)
    7655                 :            : extern tree build_simple_component_ref          (tree, tree);
    7656                 :            : extern tree build_ptrmemfunc_access_expr        (tree, tree);
    7657                 :            : extern tree build_address                       (tree);
    7658                 :            : extern tree build_nop                           (tree, tree);
    7659                 :            : extern tree non_reference                       (tree);
    7660                 :            : extern tree lookup_anon_field                   (tree, tree);
    7661                 :            : extern bool invalid_nonstatic_memfn_p           (location_t, tree,
    7662                 :            :                                                  tsubst_flags_t);
    7663                 :            : extern tree convert_member_func_to_ptr          (tree, tree, tsubst_flags_t);
    7664                 :            : extern tree convert_ptrmem                      (tree, tree, bool, bool,
    7665                 :            :                                                  tsubst_flags_t);
    7666                 :            : extern int lvalue_or_else                       (tree, enum lvalue_use,
    7667                 :            :                                                  tsubst_flags_t);
    7668                 :            : extern void check_template_keyword              (tree);
    7669                 :            : extern bool check_raw_literal_operator          (const_tree decl);
    7670                 :            : extern bool check_literal_operator_args         (const_tree, bool *, bool *);
    7671                 :            : extern void maybe_warn_about_useless_cast       (location_t, tree, tree,
    7672                 :            :                                                  tsubst_flags_t);
    7673                 :            : extern tree cp_perform_integral_promotions      (tree, tsubst_flags_t);
    7674                 :            : 
    7675                 :            : extern tree finish_left_unary_fold_expr      (tree, int);
    7676                 :            : extern tree finish_right_unary_fold_expr     (tree, int);
    7677                 :            : extern tree finish_binary_fold_expr          (tree, tree, int);
    7678                 :            : extern bool treat_lvalue_as_rvalue_p         (tree, bool);
    7679                 :            : extern bool decl_in_std_namespace_p          (tree);
    7680                 :            : 
    7681                 :            : /* in typeck2.c */
    7682                 :            : extern void require_complete_eh_spec_types      (tree, tree);
    7683                 :            : extern void cxx_incomplete_type_diagnostic      (location_t, const_tree,
    7684                 :            :                                                  const_tree, diagnostic_t);
    7685                 :            : 
    7686                 :            : inline location_t
    7687                 : 1167246536 : cp_expr_loc_or_loc (const_tree t, location_t or_loc)
    7688                 :            : {
    7689                 :  193115048 :   location_t loc = cp_expr_location (t);
    7690                 : 1167246536 :   if (loc == UNKNOWN_LOCATION)
    7691                 :  716194063 :     loc = or_loc;
    7692                 :   97111037 :   return loc;
    7693                 :            : }
    7694                 :            : 
    7695                 :            : inline location_t
    7696                 : 1165868810 : cp_expr_loc_or_input_loc (const_tree t)
    7697                 :            : {
    7698                 : 2338038469 :   return cp_expr_loc_or_loc (t, input_location);
    7699                 :            : }
    7700                 :            : 
    7701                 :            : inline void
    7702                 :        737 : cxx_incomplete_type_diagnostic (const_tree value, const_tree type,
    7703                 :            :                                 diagnostic_t diag_kind)
    7704                 :            : {
    7705                 :       1474 :   cxx_incomplete_type_diagnostic (cp_expr_loc_or_input_loc (value),
    7706                 :            :                                   value, type, diag_kind);
    7707                 :        737 : }
    7708                 :            : 
    7709                 :            : extern void cxx_incomplete_type_error           (location_t, const_tree,
    7710                 :            :                                                  const_tree);
    7711                 :            : inline void
    7712                 :        209 : cxx_incomplete_type_error (const_tree value, const_tree type)
    7713                 :            : {
    7714                 :        209 :   cxx_incomplete_type_diagnostic (value, type, DK_ERROR);
    7715                 :        178 : }
    7716                 :            : 
    7717                 :            : extern void cxx_incomplete_type_inform          (const_tree);
    7718                 :            : extern tree error_not_base_type                 (tree, tree);
    7719                 :            : extern tree binfo_or_else                       (tree, tree);
    7720                 :            : extern void cxx_readonly_error                  (location_t, tree,
    7721                 :            :                                                  enum lvalue_use);
    7722                 :            : extern void complete_type_check_abstract        (tree);
    7723                 :            : extern int abstract_virtuals_error              (tree, tree);
    7724                 :            : extern int abstract_virtuals_error              (abstract_class_use, tree);
    7725                 :            : extern int abstract_virtuals_error_sfinae       (tree, tree, tsubst_flags_t);
    7726                 :            : extern int abstract_virtuals_error_sfinae       (abstract_class_use, tree, tsubst_flags_t);
    7727                 :            : 
    7728                 :            : extern tree store_init_value                    (tree, tree, vec<tree, va_gc>**, int);
    7729                 :            : extern tree split_nonconstant_init              (tree, tree);
    7730                 :            : extern bool check_narrowing                     (tree, tree, tsubst_flags_t,
    7731                 :            :                                                  bool = false);
    7732                 :            : extern bool ordinary_char_type_p                (tree);
    7733                 :            : extern tree digest_init                         (tree, tree, tsubst_flags_t);
    7734                 :            : extern tree digest_init_flags                   (tree, tree, int, tsubst_flags_t);
    7735                 :            : extern tree digest_nsdmi_init                   (tree, tree, tsubst_flags_t);
    7736                 :            : extern tree build_scoped_ref                    (tree, tree, tree *);
    7737                 :            : extern tree build_x_arrow                       (location_t, tree,
    7738                 :            :                                                  tsubst_flags_t);
    7739                 :            : extern tree build_m_component_ref               (tree, tree, tsubst_flags_t);
    7740                 :            : extern tree build_functional_cast               (location_t, tree, tree,
    7741                 :            :                                                  tsubst_flags_t);
    7742                 :            : extern tree add_exception_specifier             (tree, tree, tsubst_flags_t);
    7743                 :            : extern tree merge_exception_specifiers          (tree, tree);
    7744                 :            : 
    7745                 :            : /* in mangle.c */
    7746                 :            : extern void init_mangle                         (void);
    7747                 :            : extern void mangle_decl                         (tree);
    7748                 :            : extern const char *mangle_type_string           (tree);
    7749                 :            : extern tree mangle_typeinfo_for_type            (tree);
    7750                 :            : extern tree mangle_typeinfo_string_for_type     (tree);
    7751                 :            : extern tree mangle_vtbl_for_type                (tree);
    7752                 :            : extern tree mangle_vtt_for_type                 (tree);
    7753                 :            : extern tree mangle_ctor_vtbl_for_type           (tree, tree);
    7754                 :            : extern tree mangle_thunk                        (tree, int, tree, tree, tree);
    7755                 :            : extern tree mangle_guard_variable               (tree);
    7756                 :            : extern tree mangle_tls_init_fn                  (tree);
    7757                 :            : extern tree mangle_tls_wrapper_fn               (tree);
    7758                 :            : extern bool decl_tls_wrapper_p                  (tree);
    7759                 :            : extern tree mangle_ref_init_variable            (tree);
    7760                 :            : extern tree mangle_template_parm_object         (tree);
    7761                 :            : extern char * get_mangled_vtable_map_var_name   (tree);
    7762                 :            : extern bool mangle_return_type_p                (tree);
    7763                 :            : extern tree mangle_decomp                       (tree, vec<tree> &);
    7764                 :            : 
    7765                 :            : /* in dump.c */
    7766                 :            : extern bool cp_dump_tree                        (void *, tree);
    7767                 :            : 
    7768                 :            : /* In cp/cp-objcp-common.c.  */
    7769                 :            : 
    7770                 :            : extern alias_set_type cxx_get_alias_set         (tree);
    7771                 :            : extern bool cxx_warn_unused_global_decl         (const_tree);
    7772                 :            : extern size_t cp_tree_size                      (enum tree_code);
    7773                 :            : extern bool cp_var_mod_type_p                   (tree, tree);
    7774                 :            : extern void cxx_initialize_diagnostics          (diagnostic_context *);
    7775                 :            : extern int cxx_types_compatible_p               (tree, tree);
    7776                 :            : extern bool cxx_block_may_fallthru              (const_tree);
    7777                 :            : 
    7778                 :            : /* in cp-gimplify.c */
    7779                 :            : extern int cp_gimplify_expr                     (tree *, gimple_seq *,
    7780                 :            :                                                  gimple_seq *);
    7781                 :            : extern void cp_genericize                       (tree);
    7782                 :            : extern bool cxx_omp_const_qual_no_mutable       (tree);
    7783                 :            : extern enum omp_clause_default_kind cxx_omp_predetermined_sharing_1 (tree);
    7784                 :            : extern enum omp_clause_default_kind cxx_omp_predetermined_sharing (tree);
    7785                 :            : extern tree cxx_omp_clause_default_ctor         (tree, tree, tree);
    7786                 :            : extern tree cxx_omp_clause_copy_ctor            (tree, tree, tree);
    7787                 :            : extern tree cxx_omp_clause_assign_op            (tree, tree, tree);
    7788                 :            : extern tree cxx_omp_clause_dtor                 (tree, tree);
    7789                 :            : extern void cxx_omp_finish_clause               (tree, gimple_seq *);
    7790                 :            : extern bool cxx_omp_privatize_by_reference      (const_tree);
    7791                 :            : extern bool cxx_omp_disregard_value_expr        (tree, bool);
    7792                 :            : extern void cp_fold_function                    (tree);
    7793                 :            : extern tree cp_fold_maybe_rvalue                (tree, bool);
    7794                 :            : extern tree cp_fold_rvalue                      (tree);
    7795                 :            : extern tree cp_fully_fold                       (tree);
    7796                 :            : extern tree cp_fully_fold_init                  (tree);
    7797                 :            : extern void clear_fold_cache                    (void);
    7798                 :            : extern tree lookup_hotness_attribute            (tree);
    7799                 :            : extern tree process_stmt_hotness_attribute      (tree, location_t);
    7800                 :            : extern bool simple_empty_class_p                (tree, tree, tree_code);
    7801                 :            : extern tree fold_builtin_source_location        (location_t);
    7802                 :            : 
    7803                 :            : /* in name-lookup.c */
    7804                 :            : extern tree strip_using_decl                    (tree);
    7805                 :            : 
    7806                 :            : /* Tell the binding oracle what kind of binding we are looking for.  */
    7807                 :            : 
    7808                 :            : enum cp_oracle_request
    7809                 :            : {
    7810                 :            :   CP_ORACLE_IDENTIFIER
    7811                 :            : };
    7812                 :            : 
    7813                 :            : /* If this is non-NULL, then it is a "binding oracle" which can lazily
    7814                 :            :    create bindings when needed by the C compiler.  The oracle is told
    7815                 :            :    the name and type of the binding to create.  It can call pushdecl
    7816                 :            :    or the like to ensure the binding is visible; or do nothing,
    7817                 :            :    leaving the binding untouched.  c-decl.c takes note of when the
    7818                 :            :    oracle has been called and will not call it again if it fails to
    7819                 :            :    create a given binding.  */
    7820                 :            : 
    7821                 :            : typedef void cp_binding_oracle_function (enum cp_oracle_request, tree identifier);
    7822                 :            : 
    7823                 :            : extern cp_binding_oracle_function *cp_binding_oracle;
    7824                 :            : 
    7825                 :            : /* Set during diagnostics to record the failed constraint. This is a
    7826                 :            :    TREE_LIST whose VALUE is the constraint and whose PURPOSE are the
    7827                 :            :    instantiation arguments Defined in pt.c.  */
    7828                 :            : 
    7829                 :            : extern tree current_failed_constraint;
    7830                 :            : 
    7831                 :            : /* An RAII class to manage the failed constraint.  */
    7832                 :            : 
    7833                 :            : struct diagnosing_failed_constraint
    7834                 :            : {
    7835                 :            :   diagnosing_failed_constraint (tree, tree, bool);
    7836                 :            :   ~diagnosing_failed_constraint ();
    7837                 :            : 
    7838                 :            :   bool diagnosing_error;
    7839                 :            : };
    7840                 :            : 
    7841                 :            : /* in constraint.cc */
    7842                 :            : 
    7843                 :            : extern cp_expr finish_constraint_or_expr        (location_t, cp_expr, cp_expr);
    7844                 :            : extern cp_expr finish_constraint_and_expr       (location_t, cp_expr, cp_expr);
    7845                 :            : extern cp_expr finish_constraint_primary_expr   (cp_expr);
    7846                 :            : extern tree finish_concept_definition           (cp_expr, tree);
    7847                 :            : extern tree combine_constraint_expressions      (tree, tree);
    7848                 :            : extern tree append_constraint                   (tree, tree);
    7849                 :            : extern tree get_constraints                     (const_tree);
    7850                 :            : extern void set_constraints                     (tree, tree);
    7851                 :            : extern void remove_constraints                  (tree);
    7852                 :            : extern tree current_template_constraints        (void);
    7853                 :            : extern tree associate_classtype_constraints     (tree);
    7854                 :            : extern tree build_constraints                   (tree, tree);
    7855                 :            : extern tree maybe_substitute_reqs_for           (tree, const_tree);
    7856                 :            : extern tree get_template_head_requirements      (tree);
    7857                 :            : extern tree get_trailing_function_requirements  (tree);
    7858                 :            : extern tree get_shorthand_constraints           (tree);
    7859                 :            :