LCOV - code coverage report
Current view: top level - gcc/cp - lex.cc (source / functions) Hit Total Coverage
Test: gcc.info Lines: 423 453 93.4 %
Date: 2023-07-19 08:18:47 Functions: 35 38 92.1 %

          Line data    Source code
       1             : /* Separate lexical analyzer for GNU C++.
       2             :    Copyright (C) 1987-2023 Free Software Foundation, Inc.
       3             :    Hacked 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             : 
      22             : /* This file is the lexical analyzer for GNU C++.  */
      23             : 
      24             : #include "config.h"
      25             : /* For use with name_hint.  */
      26             : #define INCLUDE_MEMORY
      27             : #include "system.h"
      28             : #include "coretypes.h"
      29             : #include "cp-tree.h"
      30             : #include "stringpool.h"
      31             : #include "c-family/c-pragma.h"
      32             : #include "c-family/c-objc.h"
      33             : #include "gcc-rich-location.h"
      34             : #include "cp-name-hint.h"
      35             : #include "langhooks.h"
      36             : 
      37             : static int interface_strcmp (const char *);
      38             : static void init_cp_pragma (void);
      39             : 
      40             : static tree parse_strconst_pragma (const char *, int);
      41             : static void handle_pragma_vtable (cpp_reader *);
      42             : static void handle_pragma_unit (cpp_reader *);
      43             : static void handle_pragma_interface (cpp_reader *);
      44             : static void handle_pragma_implementation (cpp_reader *);
      45             : 
      46             : static void init_operators (void);
      47             : static void copy_lang_type (tree);
      48             : 
      49             : /* A constraint that can be tested at compile time.  */
      50             : #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
      51             : 
      52             : /* Functions and data structures for #pragma interface.
      53             : 
      54             :    `#pragma implementation' means that the main file being compiled
      55             :    is considered to implement (provide) the classes that appear in
      56             :    its main body.  I.e., if this is file "foo.cc", and class `bar'
      57             :    is defined in "foo.cc", then we say that "foo.cc implements bar".
      58             : 
      59             :    All main input files "implement" themselves automagically.
      60             : 
      61             :    `#pragma interface' means that unless this file (of the form "foo.h"
      62             :    is not presently being included by file "foo.cc", the
      63             :    CLASSTYPE_INTERFACE_ONLY bit gets set.  The effect is that none
      64             :    of the vtables nor any of the inline functions defined in foo.h
      65             :    will ever be output.
      66             : 
      67             :    There are cases when we want to link files such as "defs.h" and
      68             :    "main.cc".  In this case, we give "defs.h" a `#pragma interface',
      69             :    and "main.cc" has `#pragma implementation "defs.h"'.  */
      70             : 
      71             : struct impl_files
      72             : {
      73             :   const char *filename;
      74             :   struct impl_files *next;
      75             : };
      76             : 
      77             : static struct impl_files *impl_file_chain;
      78             : 
      79             : void
      80       89094 : cxx_finish (void)
      81             : {
      82       89094 :   c_common_finish ();
      83       89094 : }
      84             : 
      85             : ovl_op_info_t ovl_op_info[2][OVL_OP_MAX] = 
      86             :   {
      87             :     {
      88             :       {NULL_TREE, NULL, NULL, ERROR_MARK, OVL_OP_ERROR_MARK, 0},
      89             :       {NULL_TREE, NULL, NULL, NOP_EXPR, OVL_OP_NOP_EXPR, 0},
      90             : #define DEF_OPERATOR(NAME, CODE, MANGLING, FLAGS) \
      91             :       {NULL_TREE, NAME, MANGLING, CODE, OVL_OP_##CODE, FLAGS},
      92             : #define OPERATOR_TRANSITION }, {                        \
      93             :       {NULL_TREE, NULL, NULL, ERROR_MARK, OVL_OP_ERROR_MARK, 0},
      94             : #include "operators.def"
      95             :     }
      96             :   };
      97             : unsigned char ovl_op_mapping[MAX_TREE_CODES];
      98             : unsigned char ovl_op_alternate[OVL_OP_MAX];
      99             : 
     100             : /* Get the name of the kind of identifier T.  */
     101             : 
     102             : const char *
     103           0 : get_identifier_kind_name (tree id)
     104             : {
     105             :   /* Keep in sync with cp_id_kind enumeration.  */
     106           0 :   static const char *const names[cik_max] = {
     107             :     "normal", "keyword", "constructor", "destructor",
     108             :     "simple-op", "assign-op", "conv-op", "<reserved>udlit-op"
     109             :   };
     110             : 
     111           0 :   unsigned kind = 0;
     112           0 :   kind |= IDENTIFIER_KIND_BIT_2 (id) << 2;
     113           0 :   kind |= IDENTIFIER_KIND_BIT_1 (id) << 1;
     114           0 :   kind |= IDENTIFIER_KIND_BIT_0 (id) << 0;
     115             : 
     116           0 :   return names[kind];
     117             : }
     118             : 
     119             : /* Set the identifier kind, which we expect to currently be zero.  */
     120             : 
     121             : void
     122    20813710 : set_identifier_kind (tree id, cp_identifier_kind kind)
     123             : {
     124    20813710 :   gcc_checking_assert (!IDENTIFIER_KIND_BIT_2 (id)
     125             :                        & !IDENTIFIER_KIND_BIT_1 (id)
     126             :                        & !IDENTIFIER_KIND_BIT_0 (id));
     127    20813710 :   IDENTIFIER_KIND_BIT_2 (id) |= (kind >> 2) & 1;
     128    20813710 :   IDENTIFIER_KIND_BIT_1 (id) |= (kind >> 1) & 1;
     129    20813710 :   IDENTIFIER_KIND_BIT_0 (id) |= (kind >> 0) & 1;
     130    20813710 : }
     131             : 
     132             : /* Create and tag the internal operator name for the overloaded
     133             :    operator PTR describes.  */
     134             : 
     135             : static tree
     136     4998560 : set_operator_ident (ovl_op_info_t *ptr)
     137             : {
     138     4998560 :   char buffer[32];
     139     9997120 :   size_t len = snprintf (buffer, sizeof (buffer), "operator%s%s",
     140     4998560 :                          &" "[ptr->name[0] && ptr->name[0] != '_'
     141     4998560 :                               && !ISALPHA (ptr->name[0])],
     142     4998560 :                          ptr->name);
     143     4998560 :   gcc_checking_assert (len < sizeof (buffer));
     144             : 
     145     4998560 :   tree ident = get_identifier_with_length (buffer, len);
     146     4998560 :   ptr->identifier = ident;
     147             : 
     148     4998560 :   return ident;
     149             : }
     150             : 
     151             : /* Initialize data structures that keep track of operator names.  */
     152             : 
     153             : static void
     154       89260 : init_operators (void)
     155             : {
     156             :   /* We rely on both these being zero.  */
     157       89260 :   gcc_checking_assert (!OVL_OP_ERROR_MARK && !ERROR_MARK);
     158             : 
     159             :   /* This loop iterates backwards because we need to move the
     160             :      assignment operators down to their correct slots.  I.e. morally
     161             :      equivalent to an overlapping memmove where dest > src.  Slot
     162             :      zero is for error_mark, so hae no operator. */
     163     5177080 :   for (unsigned ix = OVL_OP_MAX; --ix;)
     164             :     {
     165     5087820 :       ovl_op_info_t *op_ptr = &ovl_op_info[false][ix];
     166             : 
     167     5087820 :       if (op_ptr->name)
     168             :         {
     169     4016700 :           tree ident = set_operator_ident (op_ptr);
     170     4016700 :           if (unsigned index = IDENTIFIER_CP_INDEX (ident))
     171             :             {
     172      535560 :               ovl_op_info_t *bin_ptr = &ovl_op_info[false][index];
     173             : 
     174             :               /* They should only differ in unary/binary ness.  */
     175      535560 :               gcc_checking_assert ((op_ptr->flags ^ bin_ptr->flags)
     176             :                                    == OVL_OP_FLAG_AMBIARY);
     177      535560 :               bin_ptr->flags |= op_ptr->flags;
     178      535560 :               ovl_op_alternate[index] = ix;
     179             :             }
     180             :           else
     181             :             {
     182     3481140 :               IDENTIFIER_CP_INDEX (ident) = ix;
     183     3481140 :               set_identifier_kind (ident, cik_simple_op);
     184             :             }
     185             :         }
     186     5087820 :       if (op_ptr->tree_code)
     187             :         {
     188     5087820 :           gcc_checking_assert (op_ptr->ovl_op_code == ix
     189             :                                && !ovl_op_mapping[op_ptr->tree_code]);
     190     5087820 :           ovl_op_mapping[op_ptr->tree_code] = op_ptr->ovl_op_code;
     191             :         }
     192             : 
     193     5087820 :       ovl_op_info_t *as_ptr = &ovl_op_info[true][ix];
     194     5087820 :       if (as_ptr->name)
     195             :         {
     196             :           /* These will be placed at the start of the array, move to
     197             :              the correct slot and initialize.  */
     198      981860 :           if (as_ptr->ovl_op_code != ix)
     199             :             {
     200      892600 :               ovl_op_info_t *dst_ptr = &ovl_op_info[true][as_ptr->ovl_op_code];
     201      892600 :               gcc_assert (as_ptr->ovl_op_code > ix && !dst_ptr->tree_code);
     202      892600 :               memcpy (dst_ptr, as_ptr, sizeof (*dst_ptr));
     203      892600 :               memset (as_ptr, 0, sizeof (*as_ptr));
     204      892600 :               as_ptr = dst_ptr;
     205             :             }
     206             : 
     207      981860 :           tree ident = set_operator_ident (as_ptr);
     208      981860 :           gcc_checking_assert (!IDENTIFIER_CP_INDEX (ident));
     209      981860 :           IDENTIFIER_CP_INDEX (ident) = as_ptr->ovl_op_code;
     210      981860 :           set_identifier_kind (ident, cik_assign_op);
     211             : 
     212      981860 :           gcc_checking_assert (!ovl_op_mapping[as_ptr->tree_code]
     213             :                                || (ovl_op_mapping[as_ptr->tree_code]
     214             :                                    == as_ptr->ovl_op_code));
     215      981860 :           ovl_op_mapping[as_ptr->tree_code] = as_ptr->ovl_op_code;
     216             :         }
     217             :     }
     218       89260 : }
     219             : 
     220             : /* Initialize the reserved words.  */
     221             : 
     222             : void
     223       89260 : init_reswords (void)
     224             : {
     225       89260 :   unsigned int i;
     226       89260 :   tree id;
     227       89260 :   int mask = 0;
     228             : 
     229       89260 :   if (cxx_dialect < cxx11)
     230       12669 :     mask |= D_CXX11;
     231       89260 :   if (cxx_dialect < cxx20)
     232       67402 :     mask |= D_CXX20;
     233       89260 :   if (!flag_concepts)
     234       67211 :     mask |= D_CXX_CONCEPTS;
     235       89260 :   if (!flag_coroutines)
     236       66508 :     mask |= D_CXX_COROUTINES;
     237       89260 :   if (!flag_modules)
     238       86378 :     mask |= D_CXX_MODULES;
     239       89260 :   if (!flag_tm)
     240       88880 :     mask |= D_TRANSMEM;
     241       89260 :   if (!flag_char8_t)
     242       67337 :     mask |= D_CXX_CHAR8_T;
     243       89260 :   if (flag_no_asm)
     244           4 :     mask |= D_ASM | D_EXT | D_EXT11;
     245       89260 :   if (flag_no_gnu_keywords)
     246       48782 :     mask |= D_EXT | D_EXT11;
     247             : 
     248             :   /* The Objective-C keywords are all context-dependent.  */
     249       89260 :   mask |= D_OBJC;
     250             : 
     251       89260 :   ridpointers = ggc_cleared_vec_alloc<tree> ((int) RID_MAX);
     252    22225740 :   for (i = 0; i < num_c_common_reswords; i++)
     253             :     {
     254    22136480 :       if (c_common_reswords[i].disable & D_CONLY)
     255     2320760 :         continue;
     256    19815720 :       id = get_identifier (c_common_reswords[i].word);
     257    19815720 :       C_SET_RID_CODE (id, c_common_reswords[i].rid);
     258    19815720 :       ridpointers [(int) c_common_reswords[i].rid] = id;
     259    19815720 :       if (! (c_common_reswords[i].disable & mask))
     260    15454659 :         set_identifier_kind (id, cik_keyword);
     261             :     }
     262             : 
     263      178520 :   for (i = 0; i < NUM_INT_N_ENTS; i++)
     264             :     {
     265       89260 :       char name[50];
     266       89260 :       sprintf (name, "__int%d", int_n_data[i].bitsize);
     267       89260 :       id = get_identifier (name);
     268       89260 :       C_SET_RID_CODE (id, RID_FIRST_INT_N + i);
     269       89260 :       set_identifier_kind (id, cik_keyword);
     270             : 
     271       89260 :       sprintf (name, "__int%d__", int_n_data[i].bitsize);
     272       89260 :       id = get_identifier (name);
     273       89260 :       C_SET_RID_CODE (id, RID_FIRST_INT_N + i);
     274       89260 :       set_identifier_kind (id, cik_keyword);
     275             :     }
     276             : 
     277       89260 :   if (flag_openmp)
     278             :     {
     279        3451 :       id = get_identifier ("omp_all_memory");
     280        3451 :       C_SET_RID_CODE (id, RID_OMP_ALL_MEMORY);
     281        3451 :       set_identifier_kind (id, cik_keyword);
     282        3451 :       ridpointers [RID_OMP_ALL_MEMORY] = id;
     283             :     }
     284       89260 : }
     285             : 
     286             : static void
     287       88525 : init_cp_pragma (void)
     288             : {
     289       88525 :   c_register_pragma (0, "vtable", handle_pragma_vtable);
     290       88525 :   c_register_pragma (0, "unit", handle_pragma_unit);
     291       88525 :   c_register_pragma (0, "interface", handle_pragma_interface);
     292       88525 :   c_register_pragma (0, "implementation", handle_pragma_implementation);
     293       88525 :   c_register_pragma ("GCC", "interface", handle_pragma_interface);
     294       88525 :   c_register_pragma ("GCC", "implementation", handle_pragma_implementation);
     295       88525 : }
     296             : 
     297             : /* TRUE if a code represents a statement.  */
     298             : 
     299             : bool statement_code_p[MAX_TREE_CODES];
     300             : 
     301             : /* Initialize the C++ front end.  This function is very sensitive to
     302             :    the exact order that things are done here.  It would be nice if the
     303             :    initialization done by this routine were moved to its subroutines,
     304             :    and the ordering dependencies clarified and reduced.  */
     305             : bool
     306       89260 : cxx_init (void)
     307             : {
     308       89260 :   location_t saved_loc;
     309       89260 :   unsigned int i;
     310       89260 :   static const enum tree_code stmt_codes[] = {
     311             :    CTOR_INITIALIZER,    TRY_BLOCK,      HANDLER,
     312             :    EH_SPEC_BLOCK,       USING_STMT,     TAG_DEFN,
     313             :    IF_STMT,             CLEANUP_STMT,   FOR_STMT,
     314             :    RANGE_FOR_STMT,      WHILE_STMT,     DO_STMT,
     315             :    BREAK_STMT,          CONTINUE_STMT,  SWITCH_STMT,
     316             :    EXPR_STMT,           OMP_DEPOBJ
     317             :   };
     318             : 
     319       89260 :   memset (&statement_code_p, 0, sizeof (statement_code_p));
     320     1606680 :   for (i = 0; i < ARRAY_SIZE (stmt_codes); i++)
     321     1517420 :     statement_code_p[stmt_codes[i]] = true;
     322             : 
     323       89260 :   saved_loc = input_location;
     324       89260 :   input_location = BUILTINS_LOCATION;
     325             : 
     326       89260 :   init_reswords ();
     327       89260 :   init_tree ();
     328       89260 :   init_cp_semantics ();
     329       89260 :   init_operators ();
     330       89260 :   init_method ();
     331             : 
     332       89260 :   current_function_decl = NULL;
     333             : 
     334       89260 :   class_type_node = ridpointers[(int) RID_CLASS];
     335             : 
     336       89260 :   cxx_init_decl_processing ();
     337             : 
     338       89260 :   if (c_common_init () == false)
     339             :     {
     340         719 :       input_location = saved_loc;
     341         719 :       return false;
     342             :     }
     343             : 
     344       88525 :   init_cp_pragma ();
     345             : 
     346       88525 :   input_location = saved_loc;
     347       88525 :   return true;
     348             : }
     349             : 
     350             : /* Return nonzero if S is not considered part of an
     351             :    INTERFACE/IMPLEMENTATION pair.  Otherwise, return 0.  */
     352             : 
     353             : static int
     354         101 : interface_strcmp (const char* s)
     355             : {
     356             :   /* Set the interface/implementation bits for this scope.  */
     357         101 :   struct impl_files *ifiles;
     358         101 :   const char *s1;
     359             : 
     360         117 :   for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
     361             :     {
     362          62 :       const char *t1 = ifiles->filename;
     363          62 :       s1 = s;
     364             : 
     365          62 :       if (*s1 == 0 || filename_ncmp (s1, t1, 1) != 0)
     366           8 :         continue;
     367             : 
     368         590 :       while (*s1 != 0 && filename_ncmp (s1, t1, 1) == 0)
     369         536 :         s1++, t1++;
     370             : 
     371             :       /* A match.  */
     372          54 :       if (*s1 == *t1)
     373             :         return 0;
     374             : 
     375             :       /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc.  */
     376          24 :       if (strchr (s1, '.') || strchr (t1, '.'))
     377           8 :         continue;
     378             : 
     379          16 :       if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
     380           0 :         continue;
     381             : 
     382             :       /* A match.  */
     383             :       return 0;
     384             :     }
     385             : 
     386             :   /* No matches.  */
     387             :   return 1;
     388             : }
     389             : 
     390             : /* We've just read a cpp-token, figure out our next state.  Hey, this
     391             :    is a hand-coded co-routine!  */
     392             : 
     393             : struct module_token_filter
     394             : {
     395             :   enum state
     396             :   {
     397             :    idle,
     398             :    module_first,
     399             :    module_cont,
     400             :    module_end,
     401             :   };
     402             : 
     403             :   enum state state : 8;
     404             :   bool is_import : 1;
     405             :   bool got_export : 1;
     406             :   bool got_colon : 1;
     407             :   bool want_dot : 1;
     408             : 
     409             :   location_t token_loc;
     410             :   cpp_reader *reader;
     411             :   module_state *module;
     412             :   module_state *import;
     413             : 
     414        2882 :   module_token_filter (cpp_reader *reader)
     415        2882 :     : state (idle), is_import (false),
     416        2882 :     got_export (false), got_colon (false), want_dot (false),
     417        2882 :     token_loc (UNKNOWN_LOCATION),
     418        2882 :     reader (reader), module (NULL), import (NULL)
     419             :   {
     420             :   };
     421             : 
     422             :   /* Process the next token.  Note we cannot see CPP_EOF inside a
     423             :      pragma -- a CPP_PRAGMA_EOL always happens.  */
     424    28072232 :   uintptr_t resume (int type, int keyword, tree value, location_t loc)
     425             :   {
     426    28072232 :     unsigned res = 0;
     427             : 
     428    28072232 :     switch (state)
     429             :       {
     430    28062341 :       case idle:
     431    28062341 :         if (type == CPP_KEYWORD)
     432     4912761 :           switch (keyword)
     433             :             {
     434             :             default:
     435             :               break;
     436             : 
     437        1191 :             case RID__EXPORT:
     438        1191 :               got_export = true;
     439        1191 :               res = lang_hooks::PT_begin_pragma;
     440        1191 :               break;
     441             : 
     442        1593 :             case RID__IMPORT:
     443        1593 :               is_import = true;
     444             :               /* FALLTHRU */
     445        3078 :             case RID__MODULE:
     446        3078 :               state = module_first;
     447        3078 :               want_dot = false;
     448        3078 :               got_colon = false;
     449        3078 :               token_loc = loc;
     450        3078 :               import = NULL;
     451        3078 :               if (!got_export)
     452        3078 :                 res = lang_hooks::PT_begin_pragma;
     453             :               break;
     454             :             }
     455             :         break;
     456             : 
     457        3093 :       case module_first:
     458        3093 :         if (is_import && type == CPP_HEADER_NAME)
     459             :           {
     460             :             /* A header name.  The preprocessor will have already
     461             :                done include searching and canonicalization.  */
     462         670 :             state = module_end;
     463         670 :             goto header_unit;
     464             :           }
     465             :         
     466        2423 :         if (type == CPP_PADDING || type == CPP_COMMENT)
     467             :           break;
     468             : 
     469        2408 :         state = module_cont;
     470        2408 :         if (type == CPP_COLON && module)
     471             :           {
     472         120 :             got_colon = true;
     473         120 :             import = module;
     474         120 :             break;
     475             :           }
     476             :         /* FALLTHROUGH  */
     477             : 
     478        5150 :       case module_cont:
     479        5150 :         switch (type)
     480             :           {
     481             :           case CPP_PADDING:
     482             :           case CPP_COMMENT:
     483             :             break;
     484             : 
     485        2402 :           default:
     486             :             /* If we ever need to pay attention to attributes for
     487             :                header modules, more logic will be needed.  */
     488        2402 :             state = module_end;
     489        2402 :             break;
     490             : 
     491         102 :           case CPP_COLON:
     492         102 :             if (got_colon)
     493           0 :               state = module_end;
     494         102 :             got_colon = true;
     495             :             /* FALLTHROUGH  */
     496         269 :           case CPP_DOT:
     497         269 :             if (!want_dot)
     498           3 :               state = module_end;
     499         269 :             want_dot = false;
     500         269 :             break;
     501             : 
     502           3 :           case CPP_PRAGMA_EOL:
     503           3 :             goto module_end;
     504             : 
     505        2476 :           case CPP_NAME:
     506        2476 :             if (want_dot)
     507             :               {
     508             :                 /* Got name instead of [.:].  */
     509           0 :                 state = module_end;
     510           0 :                 break;
     511             :               }
     512        2476 :           header_unit:
     513        3146 :             import = get_module (value, import, got_colon);
     514        3146 :             want_dot = true;
     515        3146 :             break;
     516             :           }
     517             :         break;
     518             : 
     519        3936 :       case module_end:
     520        3936 :         if (type == CPP_PRAGMA_EOL)
     521             :           {
     522        3075 :           module_end:;
     523             :             /* End of the directive, handle the name.  */
     524        3078 :             if (import && (is_import || !flag_header_unit))
     525        5778 :               if (module_state *m
     526        2889 :                   = preprocess_module (import, token_loc, module != NULL,
     527        2889 :                                        is_import, got_export, reader))
     528        1284 :                 if (!module)
     529        1269 :                   module = m;
     530             : 
     531        3078 :             is_import = got_export = false;
     532        3078 :             state = idle;
     533             :           }
     534             :         break;
     535             :       }
     536             : 
     537    28072232 :     return res;
     538             :   }
     539             : };
     540             : 
     541             : /* Initialize or teardown.  */
     542             : 
     543             : uintptr_t
     544        6465 : module_token_cdtor (cpp_reader *pfile, uintptr_t data_)
     545             : {
     546        6465 :   if (module_token_filter *filter = reinterpret_cast<module_token_filter *> (data_))
     547             :     {
     548        2882 :       preprocessed_module (pfile);
     549        2882 :       delete filter;
     550        2882 :       data_ = 0;
     551             :     }
     552        3583 :   else if (modules_p ())
     553        2882 :     data_ = reinterpret_cast<uintptr_t > (new module_token_filter (pfile));
     554             : 
     555        6465 :   return data_;
     556             : }
     557             : 
     558             : uintptr_t
     559    28072232 : module_token_lang (int type, int keyword, tree value, location_t loc,
     560             :                    uintptr_t data_)
     561             : {
     562    28072232 :   module_token_filter *filter = reinterpret_cast<module_token_filter *> (data_);
     563    28071584 :   return filter->resume (type, keyword, value, loc);
     564             : }
     565             : 
     566             : uintptr_t
     567        1409 : module_token_pre (cpp_reader *pfile, const cpp_token *tok, uintptr_t data_)
     568             : {
     569        1409 :   if (!tok)
     570         761 :     return module_token_cdtor (pfile, data_);
     571             : 
     572         648 :   int type = tok->type;
     573         648 :   int keyword = RID_MAX;
     574         648 :   tree value = NULL_TREE;
     575             : 
     576         648 :   if (tok->type == CPP_NAME)
     577             :     {
     578         198 :       value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
     579         198 :       if (IDENTIFIER_KEYWORD_P (value))
     580             :         {
     581          84 :           keyword = C_RID_CODE (value);
     582          84 :           type = CPP_KEYWORD;
     583             :         }
     584             :     }
     585         450 :   else if (tok->type == CPP_HEADER_NAME)
     586          36 :     value = build_string (tok->val.str.len, (const char *)tok->val.str.text);
     587             : 
     588         648 :   return module_token_lang (type, keyword, value, tok->src_loc, data_);
     589             : }
     590             : 
     591             : /* Parse a #pragma whose sole argument is a string constant.
     592             :    If OPT is true, the argument is optional.  */
     593             : static tree
     594         155 : parse_strconst_pragma (const char* name, int opt)
     595             : {
     596         155 :   tree result, x;
     597         155 :   enum cpp_ttype t;
     598             : 
     599         155 :   t = pragma_lex (&result);
     600         155 :   if (t == CPP_STRING)
     601             :     {
     602          64 :       if (pragma_lex (&x) != CPP_EOF)
     603           0 :         warning (0, "junk at end of %<#pragma %s%>", name);
     604          64 :       return result;
     605             :     }
     606             : 
     607          91 :   if (t == CPP_EOF && opt)
     608             :     return NULL_TREE;
     609             : 
     610           0 :   error ("invalid %<#pragma %s%>", name);
     611           0 :   return error_mark_node;
     612             : }
     613             : 
     614             : static void
     615           0 : handle_pragma_vtable (cpp_reader* /*dfile*/)
     616             : {
     617           0 :   parse_strconst_pragma ("vtable", 0);
     618           0 :   sorry ("%<#pragma vtable%> no longer supported");
     619           0 : }
     620             : 
     621             : static void
     622           0 : handle_pragma_unit (cpp_reader* /*dfile*/)
     623             : {
     624             :   /* Validate syntax, but don't do anything.  */
     625           0 :   parse_strconst_pragma ("unit", 0);
     626           0 : }
     627             : 
     628             : static void
     629         101 : handle_pragma_interface (cpp_reader* /*dfile*/)
     630             : {
     631         101 :   tree fname = parse_strconst_pragma ("interface", 1);
     632         101 :   struct c_fileinfo *finfo;
     633         101 :   const char *filename;
     634             : 
     635         101 :   if (fname == error_mark_node)
     636             :     return;
     637         101 :   else if (fname == 0)
     638          77 :     filename = lbasename (LOCATION_FILE (input_location));
     639             :   else
     640          24 :     filename = TREE_STRING_POINTER (fname);
     641             : 
     642         101 :   finfo = get_fileinfo (LOCATION_FILE (input_location));
     643             : 
     644         101 :   if (impl_file_chain == 0)
     645             :     {
     646             :       /* If this is zero at this point, then we are
     647             :          auto-implementing.  */
     648          43 :       if (main_input_filename == 0)
     649           0 :         main_input_filename = LOCATION_FILE (input_location);
     650             :     }
     651             : 
     652         101 :   finfo->interface_only = interface_strcmp (filename);
     653             :   /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
     654             :      a definition in another file.  */
     655         101 :   if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only)
     656         101 :     finfo->interface_unknown = 0;
     657             : }
     658             : 
     659             : /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
     660             :    We used to only allow this at toplevel, but that restriction was buggy
     661             :    in older compilers and it seems reasonable to allow it in the headers
     662             :    themselves, too.  It only needs to precede the matching #p interface.
     663             : 
     664             :    We don't touch finfo->interface_only or finfo->interface_unknown;
     665             :    the user must specify a matching #p interface for this to have
     666             :    any effect.  */
     667             : 
     668             : static void
     669          54 : handle_pragma_implementation (cpp_reader* /*dfile*/)
     670             : {
     671          54 :   tree fname = parse_strconst_pragma ("implementation", 1);
     672          54 :   const char *filename;
     673          54 :   struct impl_files *ifiles = impl_file_chain;
     674             : 
     675          54 :   if (fname == error_mark_node)
     676             :     return;
     677             : 
     678          54 :   if (fname == 0)
     679             :     {
     680          14 :       if (main_input_filename)
     681             :         filename = main_input_filename;
     682             :       else
     683           0 :         filename = LOCATION_FILE (input_location);
     684          14 :       filename = lbasename (filename);
     685             :     }
     686             :   else
     687             :     {
     688          40 :       filename = TREE_STRING_POINTER (fname);
     689          40 :       if (cpp_included_before (parse_in, filename, input_location))
     690           4 :         warning (0, "%<#pragma implementation%> for %qs appears after "
     691             :                  "file is included", filename);
     692             :     }
     693             : 
     694          58 :   for (; ifiles; ifiles = ifiles->next)
     695             :     {
     696           4 :       if (! filename_cmp (ifiles->filename, filename))
     697             :         break;
     698             :     }
     699          54 :   if (ifiles == 0)
     700             :     {
     701          54 :       ifiles = XNEW (struct impl_files);
     702          54 :       ifiles->filename = xstrdup (filename);
     703          54 :       ifiles->next = impl_file_chain;
     704          54 :       impl_file_chain = ifiles;
     705             :     }
     706             : }
     707             : 
     708             : /* Issue an error message indicating that the lookup of NAME (an
     709             :    IDENTIFIER_NODE) failed.  Returns the ERROR_MARK_NODE.  */
     710             : 
     711             : tree
     712        1968 : unqualified_name_lookup_error (tree name, location_t loc)
     713             : {
     714        1968 :   if (loc == UNKNOWN_LOCATION)
     715        1426 :     loc = cp_expr_loc_or_input_loc (name);
     716             : 
     717        1968 :   if (IDENTIFIER_ANY_OP_P (name))
     718          12 :     error_at (loc, "%qD not defined", name);
     719             :   else
     720             :     {
     721        1956 :       if (!objc_diagnose_private_ivar (name))
     722             :         {
     723        1956 :           auto_diagnostic_group d;
     724        1956 :           name_hint hint = suggest_alternatives_for (loc, name, true);
     725        1956 :           if (const char *suggestion = hint.suggestion ())
     726             :             {
     727         292 :               gcc_rich_location richloc (loc);
     728         292 :               richloc.add_fixit_replace (suggestion);
     729         292 :               error_at (&richloc,
     730             :                         "%qD was not declared in this scope; did you mean %qs?",
     731             :                         name, suggestion);
     732         292 :             }
     733             :           else
     734        1664 :             error_at (loc, "%qD was not declared in this scope", name);
     735        1956 :         }
     736             :       /* Prevent repeated error messages by creating a VAR_DECL with
     737             :          this NAME in the innermost block scope.  */
     738        1956 :       if (local_bindings_p ())
     739             :         {
     740        1600 :           tree decl = build_decl (loc, VAR_DECL, name, error_mark_node);
     741        1600 :           TREE_USED (decl) = true;
     742        1600 :           pushdecl (decl);
     743             :         }
     744             :     }
     745             : 
     746        1968 :   return error_mark_node;
     747             : }
     748             : 
     749             : /* Like unqualified_name_lookup_error, but NAME_EXPR is an unqualified-id
     750             :    NAME, encapsulated with its location in a CP_EXPR, used as a function.
     751             :    Returns an appropriate expression for NAME.  */
     752             : 
     753             : tree
     754         618 : unqualified_fn_lookup_error (cp_expr name_expr)
     755             : {
     756         618 :   tree name = name_expr.get_value ();
     757         618 :   location_t loc = name_expr.get_location ();
     758         618 :   if (loc == UNKNOWN_LOCATION)
     759          52 :     loc = input_location;
     760             : 
     761         618 :   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
     762           1 :     name = TREE_OPERAND (name, 0);
     763             : 
     764         618 :   if (processing_template_decl)
     765             :     {
     766             :       /* In a template, it is invalid to write "f()" or "f(3)" if no
     767             :          declaration of "f" is available.  Historically, G++ and most
     768             :          other compilers accepted that usage since they deferred all name
     769             :          lookup until instantiation time rather than doing unqualified
     770             :          name lookup at template definition time; explain to the user what
     771             :          is going wrong.
     772             : 
     773             :          Note that we have the exact wording of the following message in
     774             :          the manual (trouble.texi, node "Name lookup"), so they need to
     775             :          be kept in synch.  */
     776          76 :       permerror (loc, "there are no arguments to %qD that depend on a template "
     777             :                  "parameter, so a declaration of %qD must be available",
     778             :                  name, name);
     779             : 
     780          76 :       if (!flag_permissive)
     781             :         {
     782          54 :           static bool hint;
     783          54 :           if (!hint)
     784             :             {
     785          44 :               inform (loc, "(if you use %<-fpermissive%>, G++ will accept your "
     786             :                       "code, but allowing the use of an undeclared name is "
     787             :                       "deprecated)");
     788          44 :               hint = true;
     789             :             }
     790             :         }
     791          76 :       return name;
     792             :     }
     793             : 
     794         542 :   return unqualified_name_lookup_error (name, loc);
     795             : }
     796             : 
     797             : 
     798             : /* Hasher for the conversion operator name hash table.  */
     799             : struct conv_type_hasher : ggc_ptr_hash<tree_node>
     800             : {
     801             :   /* Hash NODE, an identifier node in the table.  TYPE_UID is
     802             :      suitable, as we're not concerned about matching canonicalness
     803             :      here.  */
     804     6315244 :   static hashval_t hash (tree node)
     805             :   {
     806     6315244 :     return (hashval_t) TYPE_UID (TREE_TYPE (node));
     807             :   }
     808             : 
     809             :   /* Compare NODE, an identifier node in the table, against TYPE, an
     810             :      incoming TYPE being looked up.  */
     811     7238815 :   static bool equal (tree node, tree type)
     812             :   {
     813     7238815 :     return TREE_TYPE (node) == type;
     814             :   }
     815             : };
     816             : 
     817             : /* This hash table maps TYPEs to the IDENTIFIER for a conversion
     818             :    operator to TYPE.  The nodes are IDENTIFIERs whose TREE_TYPE is the
     819             :    TYPE.  */
     820             : 
     821             : static GTY (()) hash_table<conv_type_hasher> *conv_type_names;
     822             : 
     823             : /* Return an identifier for a conversion operator to TYPE.  We can get
     824             :    from the returned identifier to the type.  We store TYPE, which is
     825             :    not necessarily the canonical type,  which allows us to report the
     826             :    form the user used in error messages.  All these identifiers are
     827             :    not in the identifier hash table, and have the same string name.
     828             :    These IDENTIFIERS are not in the identifier hash table, and all
     829             :    have the same IDENTIFIER_STRING.  */
     830             : 
     831             : tree
     832     1244635 : make_conv_op_name (tree type)
     833             : {
     834     1244635 :   if (type == error_mark_node)
     835             :     return error_mark_node;
     836             : 
     837     1244631 :   if (conv_type_names == NULL)
     838       15256 :     conv_type_names = hash_table<conv_type_hasher>::create_ggc (31);
     839             : 
     840     1244631 :   tree *slot = conv_type_names->find_slot_with_hash
     841     1244631 :     (type, (hashval_t) TYPE_UID (type), INSERT);
     842     1244631 :   tree identifier = *slot;
     843     1244631 :   if (!identifier)
     844             :     {
     845             :       /* Create a raw IDENTIFIER outside of the identifier hash
     846             :          table.  */
     847      500723 :       identifier = copy_node (conv_op_identifier);
     848             : 
     849             :       /* Just in case something managed to bind.  */
     850      500723 :       IDENTIFIER_BINDING (identifier) = NULL;
     851             : 
     852             :       /* Hang TYPE off the identifier so it can be found easily later
     853             :          when performing conversions.  */
     854      500723 :       TREE_TYPE (identifier) = type;
     855             : 
     856      500723 :       *slot = identifier;
     857             :     }
     858             : 
     859             :   return identifier;
     860             : }
     861             : 
     862             : /* Wrapper around build_lang_decl_loc(). Should gradually move to
     863             :    build_lang_decl_loc() and then rename build_lang_decl_loc() back to
     864             :    build_lang_decl().  */
     865             : 
     866             : tree
     867   162865190 : build_lang_decl (enum tree_code code, tree name, tree type)
     868             : {
     869   325730380 :   return build_lang_decl_loc (input_location, code, name, type);
     870             : }
     871             : 
     872             : /* Build a decl from CODE, NAME, TYPE declared at LOC, and then add
     873             :    DECL_LANG_SPECIFIC info to the result.  */
     874             : 
     875             : tree
     876   302200897 : build_lang_decl_loc (location_t loc, enum tree_code code, tree name, tree type)
     877             : {
     878   302200897 :   tree t;
     879             : 
     880   302200897 :   t = build_decl (loc, code, name, type);
     881   302200897 :   retrofit_lang_decl (t);
     882             : 
     883   302200897 :   return t;
     884             : }
     885             : 
     886             : /* Maybe add a raw lang_decl to T, a decl.  Return true if it needed
     887             :    one.  */
     888             : 
     889             : bool
     890   690705533 : maybe_add_lang_decl_raw (tree t, bool decomp_p)
     891             : {
     892   690705533 :   size_t size;
     893   690705533 :   lang_decl_selector sel;
     894             : 
     895   690705533 :   if (decomp_p)
     896             :     sel = lds_decomp, size = sizeof (struct lang_decl_decomp);
     897   690665258 :   else if (TREE_CODE (t) == FUNCTION_DECL)
     898             :     sel = lds_fn, size = sizeof (struct lang_decl_fn);
     899   367616826 :   else if (TREE_CODE (t) == NAMESPACE_DECL)
     900             :     sel = lds_ns, size = sizeof (struct lang_decl_ns);
     901   366961618 :   else if (TREE_CODE (t) == PARM_DECL)
     902             :     sel = lds_parm, size = sizeof (struct lang_decl_parm);
     903   179012806 :   else if (LANG_DECL_HAS_MIN (t))
     904             :     sel = lds_min, size = sizeof (struct lang_decl_min);
     905             :   else
     906             :     return false;
     907             : 
     908   690705533 :   struct lang_decl *ld
     909   690705533 :     = (struct lang_decl *) ggc_internal_cleared_alloc (size);
     910             : 
     911   690705533 :   ld->u.base.selector = sel;
     912   690705533 :   DECL_LANG_SPECIFIC (t) = ld;
     913             : 
     914   690705533 :   if (sel == lds_ns)
     915             :     /* Who'd create a namespace, only to put nothing in it?  */
     916      655208 :     ld->u.ns.bindings = hash_table<named_decl_hash>::create_ggc (499);
     917             : 
     918             :   if (GATHER_STATISTICS)
     919             :     {
     920             :       tree_node_counts[(int)lang_decl] += 1;
     921             :       tree_node_sizes[(int)lang_decl] += size;
     922             :     }
     923             :   return true;
     924             : }
     925             : 
     926             : /* T has just had a decl_lang_specific added.  Initialize its
     927             :    linkage.  */
     928             : 
     929             : static void
     930   687995122 : set_decl_linkage (tree t)
     931             : {
     932   687995122 :   if (current_lang_name == lang_name_cplusplus
     933   687995122 :       || decl_linkage (t) == lk_none)
     934   442575233 :     SET_DECL_LANGUAGE (t, lang_cplusplus);
     935   245419889 :   else if (current_lang_name == lang_name_c)
     936   245419889 :     SET_DECL_LANGUAGE (t, lang_c);
     937             :   else
     938           0 :     gcc_unreachable ();
     939   687995122 : }
     940             : 
     941             : /* T is a VAR_DECL node that needs to be a decomposition of BASE.  */
     942             : 
     943             : void
     944       69282 : fit_decomposition_lang_decl (tree t, tree base)
     945             : {
     946       69282 :   if (struct lang_decl *orig_ld = DECL_LANG_SPECIFIC (t))
     947             :     {
     948       30222 :       if (orig_ld->u.base.selector == lds_min)
     949             :         {
     950         434 :           maybe_add_lang_decl_raw (t, true);
     951         434 :           memcpy (DECL_LANG_SPECIFIC (t), orig_ld,
     952             :                   sizeof (struct lang_decl_min));
     953             :           /* Reset selector, which will have been bashed by the
     954             :              memcpy.  */
     955         434 :           DECL_LANG_SPECIFIC (t)->u.base.selector = lds_decomp;
     956             :         }
     957             :       else
     958       29788 :         gcc_checking_assert (orig_ld->u.base.selector == lds_decomp);
     959             :     }
     960             :   else
     961             :     {
     962       39060 :       maybe_add_lang_decl_raw (t, true);
     963       39060 :       set_decl_linkage (t);
     964             :     }
     965             : 
     966       69282 :   DECL_DECOMP_BASE (t) = base;
     967       69282 : }
     968             : 
     969             : /* Add DECL_LANG_SPECIFIC info to T, if it needs one.  Generally
     970             :    every C++ decl needs one, but C builtins etc do not.   */
     971             : 
     972             : void
     973   828431272 : retrofit_lang_decl (tree t)
     974             : {
     975   828431272 :   if (DECL_LANG_SPECIFIC (t))
     976             :     return;
     977             : 
     978   687956062 :   if (maybe_add_lang_decl_raw (t, false))
     979   687956062 :     set_decl_linkage (t);
     980             : }
     981             : 
     982             : void
     983   459157767 : cxx_dup_lang_specific_decl (tree node)
     984             : {
     985   459157767 :   int size;
     986             : 
     987   459157767 :   if (! DECL_LANG_SPECIFIC (node))
     988             :     return;
     989             : 
     990   351364407 :   switch (DECL_LANG_SPECIFIC (node)->u.base.selector)
     991             :     {
     992             :     case lds_min:
     993             :       size = sizeof (struct lang_decl_min);
     994             :       break;
     995             :     case lds_fn:
     996             :       size = sizeof (struct lang_decl_fn);
     997             :       break;
     998             :     case lds_ns:
     999             :       size = sizeof (struct lang_decl_ns);
    1000             :       break;
    1001             :     case lds_parm:
    1002             :       size = sizeof (struct lang_decl_parm);
    1003             :       break;
    1004             :     case lds_decomp:
    1005             :       size = sizeof (struct lang_decl_decomp);
    1006             :       break;
    1007           0 :     default:
    1008           0 :       gcc_unreachable ();
    1009             :     }
    1010             : 
    1011   351364407 :   struct lang_decl *ld = (struct lang_decl *) ggc_internal_alloc (size);
    1012   351364407 :   memcpy (ld, DECL_LANG_SPECIFIC (node), size);
    1013   351364407 :   DECL_LANG_SPECIFIC (node) = ld;
    1014             : 
    1015             :   /* Directly clear some flags that do not apply to the copy
    1016             :      (module_purview_p still does).  */
    1017   351364407 :   ld->u.base.module_entity_p = false;
    1018   351364407 :   ld->u.base.module_import_p = false;
    1019   351364407 :   ld->u.base.module_keyed_decls_p = false;
    1020             : 
    1021   351364407 :   if (GATHER_STATISTICS)
    1022             :     {
    1023             :       tree_node_counts[(int)lang_decl] += 1;
    1024             :       tree_node_sizes[(int)lang_decl] += size;
    1025             :     }
    1026             : }
    1027             : 
    1028             : /* Copy DECL, including any language-specific parts.  */
    1029             : 
    1030             : tree
    1031   286687565 : copy_decl (tree decl MEM_STAT_DECL)
    1032             : {
    1033   286687565 :   tree copy;
    1034             : 
    1035   286687565 :   copy = copy_node (decl PASS_MEM_STAT);
    1036   286687565 :   cxx_dup_lang_specific_decl (copy);
    1037   286687565 :   return copy;
    1038             : }
    1039             : 
    1040             : /* Replace the shared language-specific parts of NODE with a new copy.  */
    1041             : 
    1042             : static void
    1043     7975612 : copy_lang_type (tree node)
    1044             : {
    1045     7975612 :   if (! TYPE_LANG_SPECIFIC (node))
    1046             :     return;
    1047             : 
    1048           0 :   auto *lt = (struct lang_type *) ggc_internal_alloc (sizeof (struct lang_type));
    1049             : 
    1050           0 :   memcpy (lt, TYPE_LANG_SPECIFIC (node), (sizeof (struct lang_type)));
    1051           0 :   TYPE_LANG_SPECIFIC (node) = lt;
    1052             : 
    1053           0 :   if (GATHER_STATISTICS)
    1054             :     {
    1055             :       tree_node_counts[(int)lang_type] += 1;
    1056             :       tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
    1057             :     }
    1058             : }
    1059             : 
    1060             : /* Copy TYPE, including any language-specific parts.  */
    1061             : 
    1062             : tree
    1063     7975612 : copy_type (tree type MEM_STAT_DECL)
    1064             : {
    1065     7975612 :   tree copy;
    1066             : 
    1067     7975612 :   copy = copy_node (type PASS_MEM_STAT);
    1068     7975612 :   copy_lang_type (copy);
    1069     7975612 :   return copy;
    1070             : }
    1071             : 
    1072             : /* Add a raw lang_type to T, a type, should it need one.  */
    1073             : 
    1074             : bool
    1075   447553998 : maybe_add_lang_type_raw (tree t)
    1076             : {
    1077   447553998 :   if (!RECORD_OR_UNION_CODE_P (TREE_CODE (t)))
    1078             :     return false;
    1079             :   
    1080    75552034 :   auto *lt = (struct lang_type *) (ggc_internal_cleared_alloc
    1081    75552034 :                                    (sizeof (struct lang_type)));
    1082    75552034 :   TYPE_LANG_SPECIFIC (t) = lt;
    1083             : 
    1084    75552034 :   if (GATHER_STATISTICS)
    1085             :     {
    1086             :       tree_node_counts[(int)lang_type] += 1;
    1087             :       tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
    1088             :     }
    1089             : 
    1090    75552034 :   return true;
    1091             : }
    1092             : 
    1093             : tree
    1094   447343490 : cxx_make_type (enum tree_code code MEM_STAT_DECL)
    1095             : {
    1096   447343490 :   tree t = make_node (code PASS_MEM_STAT);
    1097             : 
    1098   447343490 :   if (maybe_add_lang_type_raw (t))
    1099             :     {
    1100             :       /* Set up some flags that give proper default behavior.  */
    1101    75341526 :       struct c_fileinfo *finfo =
    1102    75341526 :         get_fileinfo (LOCATION_FILE (input_location));
    1103    75341526 :       SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown);
    1104    75341526 :       CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
    1105             :     }
    1106             : 
    1107   447343490 :   if (code == RECORD_TYPE || code == UNION_TYPE)
    1108    75341526 :     TYPE_CXX_ODR_P (t) = 1;
    1109             : 
    1110   447343490 :   return t;
    1111             : }
    1112             : 
    1113             : /* A wrapper without the memory stats for LANG_HOOKS_MAKE_TYPE.  */
    1114             : 
    1115             : tree
    1116      121192 : cxx_make_type_hook (enum tree_code code)
    1117             : {
    1118      121192 :   return cxx_make_type (code);
    1119             : }
    1120             : 
    1121             : tree
    1122    75220331 : make_class_type (enum tree_code code MEM_STAT_DECL)
    1123             : {
    1124    75220331 :   tree t = cxx_make_type (code PASS_MEM_STAT);
    1125    75220331 :   SET_CLASS_TYPE_P (t, 1);
    1126    75220331 :   return t;
    1127             : }
    1128             : 
    1129             : /* Returns true if we are currently in the main source file, or in a
    1130             :    template instantiation started from the main source file.  */
    1131             : 
    1132             : bool
    1133         152 : in_main_input_context (void)
    1134             : {
    1135         152 :   struct tinst_level *tl = outermost_tinst_level();
    1136             : 
    1137         152 :   if (tl)
    1138           9 :     return filename_cmp (main_input_filename,
    1139          18 :                          LOCATION_FILE (tl->locus)) == 0;
    1140             :   else
    1141         143 :     return filename_cmp (main_input_filename, LOCATION_FILE (input_location)) == 0;
    1142             : }
    1143             : 
    1144             : #include "gt-cp-lex.h"

Generated by: LCOV version 1.16