LCOV - code coverage report
Current view: top level - gcc/c-family - c-lex.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 548 718 76.3 %
Date: 2020-03-28 11:57:23 Functions: 21 23 91.3 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Mainly the interface between cpplib and the C front ends.
       2                 :            :    Copyright (C) 1987-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify it under
       7                 :            : the terms of the GNU General Public License as published by the Free
       8                 :            : Software Foundation; either version 3, or (at your option) any later
       9                 :            : version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #include "config.h"
      21                 :            : #include "system.h"
      22                 :            : #include "coretypes.h"
      23                 :            : #include "target.h"
      24                 :            : #include "c-common.h"
      25                 :            : #include "timevar.h"
      26                 :            : #include "stringpool.h"
      27                 :            : #include "stor-layout.h"
      28                 :            : #include "c-pragma.h"
      29                 :            : #include "debug.h"
      30                 :            : #include "file-prefix-map.h" /* remap_macro_filename()  */
      31                 :            : 
      32                 :            : #include "attribs.h"
      33                 :            : 
      34                 :            : /* We may keep statistics about how long which files took to compile.  */
      35                 :            : static int header_time, body_time;
      36                 :            : static splay_tree file_info_tree;
      37                 :            : 
      38                 :            : int pending_lang_change; /* If we need to switch languages - C++ only */
      39                 :            : int c_header_level;      /* depth in C headers - C++ only */
      40                 :            : 
      41                 :            : static tree interpret_integer (const cpp_token *, unsigned int,
      42                 :            :                                enum overflow_type *);
      43                 :            : static tree interpret_float (const cpp_token *, unsigned int, const char *,
      44                 :            :                              enum overflow_type *);
      45                 :            : static tree interpret_fixed (const cpp_token *, unsigned int);
      46                 :            : static enum integer_type_kind narrowest_unsigned_type
      47                 :            :         (const widest_int &, unsigned int);
      48                 :            : static enum integer_type_kind narrowest_signed_type
      49                 :            :         (const widest_int &, unsigned int);
      50                 :            : static enum cpp_ttype lex_string (const cpp_token *, tree *, bool, bool);
      51                 :            : static tree lex_charconst (const cpp_token *);
      52                 :            : static void update_header_times (const char *);
      53                 :            : static int dump_one_header (splay_tree_node, void *);
      54                 :            : static void cb_line_change (cpp_reader *, const cpp_token *, int);
      55                 :            : static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
      56                 :            : static void cb_def_pragma (cpp_reader *, unsigned int);
      57                 :            : static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
      58                 :            : static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
      59                 :            : 
      60                 :            : void
      61                 :     155065 : init_c_lex (void)
      62                 :            : {
      63                 :     155065 :   struct cpp_callbacks *cb;
      64                 :     155065 :   struct c_fileinfo *toplevel;
      65                 :            : 
      66                 :            :   /* The get_fileinfo data structure must be initialized before
      67                 :            :      cpp_read_main_file is called.  */
      68                 :     155065 :   toplevel = get_fileinfo ("<top level>");
      69                 :     155065 :   if (flag_detailed_statistics)
      70                 :            :     {
      71                 :          0 :       header_time = 0;
      72                 :          0 :       body_time = get_run_time ();
      73                 :          0 :       toplevel->time = body_time;
      74                 :            :     }
      75                 :            : 
      76                 :     155065 :   cb = cpp_get_callbacks (parse_in);
      77                 :            : 
      78                 :     155065 :   cb->line_change = cb_line_change;
      79                 :     155065 :   cb->ident = cb_ident;
      80                 :     155065 :   cb->def_pragma = cb_def_pragma;
      81                 :     155065 :   cb->valid_pch = c_common_valid_pch;
      82                 :     155065 :   cb->read_pch = c_common_read_pch;
      83                 :     155065 :   cb->has_attribute = c_common_has_attribute;
      84                 :     155065 :   cb->has_builtin = c_common_has_builtin;
      85                 :     155065 :   cb->get_source_date_epoch = cb_get_source_date_epoch;
      86                 :     155065 :   cb->get_suggestion = cb_get_suggestion;
      87                 :     155065 :   cb->remap_filename = remap_macro_filename;
      88                 :            : 
      89                 :            :   /* Set the debug callbacks if we can use them.  */
      90                 :     155065 :   if ((debug_info_level == DINFO_LEVEL_VERBOSE
      91                 :       1545 :        && (write_symbols == DWARF2_DEBUG
      92                 :       1545 :            || write_symbols == VMS_AND_DWARF2_DEBUG))
      93                 :     154538 :       || flag_dump_go_spec != NULL)
      94                 :            :     {
      95                 :        530 :       cb->define = cb_define;
      96                 :        530 :       cb->undef = cb_undef;
      97                 :            :     }
      98                 :     155065 : }
      99                 :            : 
     100                 :            : struct c_fileinfo *
     101                 :   43985900 : get_fileinfo (const char *name)
     102                 :            : {
     103                 :   43985900 :   splay_tree_node n;
     104                 :   43985900 :   struct c_fileinfo *fi;
     105                 :            : 
     106                 :   43985900 :   if (!file_info_tree)
     107                 :     155453 :     file_info_tree = splay_tree_new (splay_tree_compare_strings,
     108                 :            :                                      0,
     109                 :            :                                      splay_tree_delete_pointers);
     110                 :            : 
     111                 :   43985900 :   n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
     112                 :   43985900 :   if (n)
     113                 :   42979300 :     return (struct c_fileinfo *) n->value;
     114                 :            : 
     115                 :    1006580 :   fi = XNEW (struct c_fileinfo);
     116                 :    1006580 :   fi->time = 0;
     117                 :    1006580 :   fi->interface_only = 0;
     118                 :    1006580 :   fi->interface_unknown = 1;
     119                 :    1006580 :   splay_tree_insert (file_info_tree, (splay_tree_key) name,
     120                 :            :                      (splay_tree_value) fi);
     121                 :    1006580 :   return fi;
     122                 :            : }
     123                 :            : 
     124                 :            : static void
     125                 :    6040170 : update_header_times (const char *name)
     126                 :            : {
     127                 :            :   /* Changing files again.  This means currently collected time
     128                 :            :      is charged against header time, and body time starts back at 0.  */
     129                 :    6040170 :   if (flag_detailed_statistics)
     130                 :            :     {
     131                 :          0 :       int this_time = get_run_time ();
     132                 :          0 :       struct c_fileinfo *file = get_fileinfo (name);
     133                 :          0 :       header_time += this_time - body_time;
     134                 :          0 :       file->time += this_time - body_time;
     135                 :          0 :       body_time = this_time;
     136                 :            :     }
     137                 :    6040170 : }
     138                 :            : 
     139                 :            : static int
     140                 :          0 : dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy))
     141                 :            : {
     142                 :          0 :   print_time ((const char *) n->key,
     143                 :          0 :               ((struct c_fileinfo *) n->value)->time);
     144                 :          0 :   return 0;
     145                 :            : }
     146                 :            : 
     147                 :            : void
     148                 :          0 : dump_time_statistics (void)
     149                 :            : {
     150                 :          0 :   struct c_fileinfo *file = get_fileinfo (LOCATION_FILE (input_location));
     151                 :          0 :   int this_time = get_run_time ();
     152                 :          0 :   file->time += this_time - body_time;
     153                 :            : 
     154                 :          0 :   fprintf (stderr, "\n******\n");
     155                 :          0 :   print_time ("header files (total)", header_time);
     156                 :          0 :   print_time ("main file (total)", this_time - body_time);
     157                 :          0 :   fprintf (stderr, "ratio = %g : 1\n",
     158                 :          0 :            (double) header_time / (double) (this_time - body_time));
     159                 :          0 :   fprintf (stderr, "\n******\n");
     160                 :            : 
     161                 :          0 :   splay_tree_foreach (file_info_tree, dump_one_header, 0);
     162                 :          0 : }
     163                 :            : 
     164                 :            : static void
     165                 :         20 : cb_ident (cpp_reader * ARG_UNUSED (pfile),
     166                 :            :           unsigned int ARG_UNUSED (line),
     167                 :            :           const cpp_string * ARG_UNUSED (str))
     168                 :            : {
     169                 :         20 :   if (!flag_no_ident)
     170                 :            :     {
     171                 :            :       /* Convert escapes in the string.  */
     172                 :         20 :       cpp_string cstr = { 0, 0 };
     173                 :         20 :       if (cpp_interpret_string (pfile, str, 1, &cstr, CPP_STRING))
     174                 :            :         {
     175                 :         20 :           targetm.asm_out.output_ident ((const char *) cstr.text);
     176                 :         20 :           free (CONST_CAST (unsigned char *, cstr.text));
     177                 :            :         }
     178                 :            :     }
     179                 :         20 : }
     180                 :            : 
     181                 :            : /* Called at the start of every non-empty line.  TOKEN is the first
     182                 :            :    lexed token on the line.  Used for diagnostic line numbers.  */
     183                 :            : static void
     184                 :  290047000 : cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token,
     185                 :            :                 int parsing_args)
     186                 :            : {
     187                 :  290047000 :   if (token->type != CPP_EOF && !parsing_args)
     188                 :  288903000 :     input_location = token->src_loc;
     189                 :  290047000 : }
     190                 :            : 
     191                 :            : void
     192                 :    6194940 : fe_file_change (const line_map_ordinary *new_map)
     193                 :            : {
     194                 :    6194940 :   if (new_map == NULL)
     195                 :            :     return;
     196                 :            : 
     197                 :    6040170 :   if (new_map->reason == LC_ENTER)
     198                 :            :     {
     199                 :            :       /* Don't stack the main buffer on the input stack;
     200                 :            :          we already did in compile_file.  */
     201                 :    2758680 :       if (!MAIN_FILE_P (new_map))
     202                 :            :         {
     203                 :    2603620 :           location_t included_at = linemap_included_from (new_map);
     204                 :    2603620 :           int line = 0;
     205                 :    2603620 :           if (included_at > BUILTINS_LOCATION)
     206                 :    2603620 :             line = SOURCE_LINE (new_map - 1, included_at);
     207                 :            : 
     208                 :    2603620 :           input_location = new_map->start_location;
     209                 :    2603620 :           (*debug_hooks->start_source_file) (line, LINEMAP_FILE (new_map));
     210                 :            : #ifdef SYSTEM_IMPLICIT_EXTERN_C
     211                 :            :           if (c_header_level)
     212                 :            :             ++c_header_level;
     213                 :            :           else if (LINEMAP_SYSP (new_map) == 2)
     214                 :            :             {
     215                 :            :               c_header_level = 1;
     216                 :            :               ++pending_lang_change;
     217                 :            :             }
     218                 :            : #endif
     219                 :            :         }
     220                 :            :     }
     221                 :    3281480 :   else if (new_map->reason == LC_LEAVE)
     222                 :            :     {
     223                 :            : #ifdef SYSTEM_IMPLICIT_EXTERN_C
     224                 :            :       if (c_header_level && --c_header_level == 0)
     225                 :            :         {
     226                 :            :           if (LINEMAP_SYSP (new_map) == 2)
     227                 :            :             warning (0, "badly nested C headers from preprocessor");
     228                 :            :           --pending_lang_change;
     229                 :            :         }
     230                 :            : #endif
     231                 :    2603620 :       input_location = new_map->start_location;
     232                 :            : 
     233                 :    2603620 :       (*debug_hooks->end_source_file) (LINEMAP_LINE (new_map));
     234                 :            :     }
     235                 :            : 
     236                 :    6040170 :   update_header_times (LINEMAP_FILE (new_map));
     237                 :    6040170 :   input_location = new_map->start_location;
     238                 :            : }
     239                 :            : 
     240                 :            : static void
     241                 :        663 : cb_def_pragma (cpp_reader *pfile, location_t loc)
     242                 :            : {
     243                 :            :   /* Issue a warning message if we have been asked to do so.  Ignore
     244                 :            :      unknown pragmas in system headers unless an explicit
     245                 :            :      -Wunknown-pragmas has been given.  */
     246                 :        663 :   if (warn_unknown_pragmas > in_system_header_at (input_location))
     247                 :            :     {
     248                 :         33 :       const unsigned char *space, *name;
     249                 :         33 :       const cpp_token *s;
     250                 :         33 :       location_t fe_loc = loc;
     251                 :            : 
     252                 :         33 :       space = name = (const unsigned char *) "";
     253                 :         33 :       s = cpp_get_token (pfile);
     254                 :         33 :       if (s->type != CPP_EOF)
     255                 :            :         {
     256                 :         32 :           space = cpp_token_as_text (pfile, s);
     257                 :         32 :           s = cpp_get_token (pfile);
     258                 :         32 :           if (s->type == CPP_NAME)
     259                 :         21 :             name = cpp_token_as_text (pfile, s);
     260                 :            :         }
     261                 :            : 
     262                 :         33 :       warning_at (fe_loc, OPT_Wunknown_pragmas, "ignoring %<#pragma %s %s%>",
     263                 :            :                   space, name);
     264                 :            :     }
     265                 :        663 : }
     266                 :            : 
     267                 :            : /* #define callback for DWARF and DWARF2 debug info.  */
     268                 :            : static void
     269                 :     217140 : cb_define (cpp_reader *pfile, location_t loc, cpp_hashnode *node)
     270                 :            : {
     271                 :     217140 :   const struct line_map *map = linemap_lookup (line_table, loc);
     272                 :     217140 :   (*debug_hooks->define) (SOURCE_LINE (linemap_check_ordinary (map), loc),
     273                 :     217140 :                           (const char *) cpp_macro_definition (pfile, node));
     274                 :     217140 : }
     275                 :            : 
     276                 :            : /* #undef callback for DWARF and DWARF2 debug info.  */
     277                 :            : static void
     278                 :       1125 : cb_undef (cpp_reader * ARG_UNUSED (pfile), location_t loc,
     279                 :            :           cpp_hashnode *node)
     280                 :            : {
     281                 :       1125 :   const struct line_map *map = linemap_lookup (line_table, loc);
     282                 :       1125 :   (*debug_hooks->undef) (SOURCE_LINE (linemap_check_ordinary (map), loc),
     283                 :       1125 :                          (const char *) NODE_NAME (node));
     284                 :       1125 : }
     285                 :            : 
     286                 :            : /* Wrapper around cpp_get_token to skip CPP_PADDING tokens
     287                 :            :    and not consume CPP_EOF.  */
     288                 :            : static const cpp_token *
     289                 :       7645 : get_token_no_padding (cpp_reader *pfile)
     290                 :            : {
     291                 :       8017 :   for (;;)
     292                 :            :     {
     293                 :       8017 :       const cpp_token *ret = cpp_peek_token (pfile, 0);
     294                 :       8017 :       if (ret->type == CPP_EOF)
     295                 :         22 :         return ret;
     296                 :       7995 :       ret = cpp_get_token (pfile);
     297                 :       7995 :       if (ret->type != CPP_PADDING)
     298                 :       7623 :         return ret;
     299                 :            :     }
     300                 :            : }
     301                 :            : 
     302                 :            : /* Callback for has_attribute.  */
     303                 :            : int
     304                 :        391 : c_common_has_attribute (cpp_reader *pfile)
     305                 :            : {
     306                 :        391 :   int result = 0;
     307                 :        391 :   tree attr_name = NULL_TREE;
     308                 :        391 :   const cpp_token *token;
     309                 :            : 
     310                 :        391 :   token = get_token_no_padding (pfile);
     311                 :        391 :   if (token->type != CPP_OPEN_PAREN)
     312                 :            :     {
     313                 :          0 :       cpp_error (pfile, CPP_DL_ERROR,
     314                 :            :                  "missing '(' after \"__has_attribute\"");
     315                 :          0 :       return 0;
     316                 :            :     }
     317                 :        391 :   token = get_token_no_padding (pfile);
     318                 :        391 :   if (token->type == CPP_NAME)
     319                 :            :     {
     320                 :        388 :       attr_name = get_identifier ((const char *)
     321                 :            :                                   cpp_token_as_text (pfile, token));
     322                 :        388 :       attr_name = canonicalize_attr_name (attr_name);
     323                 :        388 :       if (c_dialect_cxx ())
     324                 :            :         {
     325                 :            :           int idx = 0;
     326                 :        372 :           const cpp_token *nxt_token;
     327                 :        372 :           do
     328                 :        372 :             nxt_token = cpp_peek_token (pfile, idx++);
     329                 :        372 :           while (nxt_token->type == CPP_PADDING);
     330                 :        312 :           if (nxt_token->type == CPP_SCOPE)
     331                 :            :             {
     332                 :         64 :               get_token_no_padding (pfile); // Eat scope.
     333                 :         64 :               nxt_token = get_token_no_padding (pfile);
     334                 :         64 :               if (nxt_token->type == CPP_NAME)
     335                 :            :                 {
     336                 :         64 :                   tree attr_ns = attr_name;
     337                 :         64 :                   tree attr_id
     338                 :         64 :                     = get_identifier ((const char *)
     339                 :            :                                       cpp_token_as_text (pfile, nxt_token));
     340                 :         64 :                   attr_name = build_tree_list (attr_ns, attr_id);
     341                 :            :                 }
     342                 :            :               else
     343                 :            :                 {
     344                 :          0 :                   cpp_error (pfile, CPP_DL_ERROR,
     345                 :            :                              "attribute identifier required after scope");
     346                 :          0 :                   attr_name = NULL_TREE;
     347                 :            :                 }
     348                 :            :             }
     349                 :            :           else
     350                 :            :             {
     351                 :            :               /* Some standard attributes need special handling.  */
     352                 :        248 :               if (is_attribute_p ("noreturn", attr_name))
     353                 :            :                 result = 200809;
     354                 :        191 :               else if (is_attribute_p ("deprecated", attr_name))
     355                 :            :                 result = 201309;
     356                 :        151 :               else if (is_attribute_p ("maybe_unused", attr_name)
     357                 :        151 :                        || is_attribute_p ("fallthrough", attr_name))
     358                 :            :                 result = 201603;
     359                 :        143 :               else if (is_attribute_p ("no_unique_address", attr_name)
     360                 :        141 :                        || is_attribute_p ("likely", attr_name)
     361                 :        282 :                        || is_attribute_p ("unlikely", attr_name))
     362                 :            :                 result = 201803;
     363                 :        137 :               else if (is_attribute_p ("nodiscard", attr_name))
     364                 :            :                 result = 201907;
     365                 :            :               if (result)
     366                 :            :                 attr_name = NULL_TREE;
     367                 :            :             }
     368                 :            :         }
     369                 :        272 :       if (attr_name)
     370                 :            :         {
     371                 :        272 :           init_attributes ();
     372                 :        272 :           const struct attribute_spec *attr = lookup_attribute_spec (attr_name);
     373                 :        272 :           if (attr)
     374                 :        236 :             result = 1;
     375                 :            :         }
     376                 :            :     }
     377                 :            :   else
     378                 :            :     {
     379                 :          3 :       cpp_error (pfile, CPP_DL_ERROR,
     380                 :            :                  "macro \"__has_attribute\" requires an identifier");
     381                 :          3 :       return 0;
     382                 :            :     }
     383                 :            : 
     384                 :        388 :   if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
     385                 :          2 :     cpp_error (pfile, CPP_DL_ERROR,
     386                 :            :                "missing ')' after \"__has_attribute\"");
     387                 :            : 
     388                 :            :   return result;
     389                 :            : }
     390                 :            : 
     391                 :            : /* Callback for has_builtin.  */
     392                 :            : 
     393                 :            : int
     394                 :       2089 : c_common_has_builtin (cpp_reader *pfile)
     395                 :            : {
     396                 :       2089 :   const cpp_token *token = get_token_no_padding (pfile);
     397                 :       2089 :   if (token->type != CPP_OPEN_PAREN)
     398                 :            :     {
     399                 :          5 :       cpp_error (pfile, CPP_DL_ERROR,
     400                 :            :                  "missing '(' after \"__has_builtin\"");
     401                 :          5 :       return 0;
     402                 :            :     }
     403                 :            : 
     404                 :       2084 :   const char *name = "";
     405                 :       2084 :   token = get_token_no_padding (pfile);
     406                 :       2084 :   if (token->type == CPP_NAME)
     407                 :            :     {
     408                 :       2044 :       name = (const char *) cpp_token_as_text (pfile, token);
     409                 :       2044 :       token = get_token_no_padding (pfile);
     410                 :       2044 :       if (token->type != CPP_CLOSE_PAREN)
     411                 :            :         {
     412                 :         20 :           cpp_error (pfile, CPP_DL_ERROR,
     413                 :            :                      "expected ')' after \"%s\"", name);
     414                 :         20 :           name = "";
     415                 :            :         }
     416                 :            :     }
     417                 :            :   else
     418                 :            :     {
     419                 :         40 :       cpp_error (pfile, CPP_DL_ERROR,
     420                 :            :                  "macro \"__has_builtin\" requires an identifier");
     421                 :         40 :       if (token->type == CPP_CLOSE_PAREN)
     422                 :            :         return 0;
     423                 :            :     }
     424                 :            : 
     425                 :            :   /* Consume tokens up to the closing parenthesis, including any nested
     426                 :            :      pairs of parentheses, to avoid confusing redundant errors.  */
     427                 :       2209 :   for (unsigned nparen = 1; ; token = get_token_no_padding (pfile))
     428                 :            :     {
     429                 :       2209 :       if (token->type == CPP_OPEN_PAREN)
     430                 :         30 :         ++nparen;
     431                 :       2179 :       else if (token->type == CPP_CLOSE_PAREN)
     432                 :       2084 :         --nparen;
     433                 :         95 :       else if (token->type == CPP_EOF)
     434                 :            :         break;
     435                 :       2194 :       if (!nparen)
     436                 :            :         break;
     437                 :            :     }
     438                 :            : 
     439                 :       2079 :   return names_builtin_p (name);
     440                 :            : }
     441                 :            : 
     442                 :            : 
     443                 :            : /* Read a token and return its type.  Fill *VALUE with its value, if
     444                 :            :    applicable.  Fill *CPP_FLAGS with the token's flags, if it is
     445                 :            :    non-NULL.  */
     446                 :            : 
     447                 :            : enum cpp_ttype
     448                 : 2032130000 : c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags,
     449                 :            :                   int lex_flags)
     450                 :            : {
     451                 : 2032130000 :   const cpp_token *tok;
     452                 : 2032130000 :   enum cpp_ttype type;
     453                 : 2032130000 :   unsigned char add_flags = 0;
     454                 : 2032130000 :   enum overflow_type overflow = OT_NONE;
     455                 :            : 
     456                 : 2032130000 :   timevar_push (TV_CPP);
     457                 : 2338800000 :  retry:
     458                 : 2338800000 :   tok = cpp_get_token_with_location (parse_in, loc);
     459                 : 2338800000 :   type = tok->type;
     460                 :            : 
     461                 : 2338800000 :  retry_after_at:
     462                 : 2338800000 :   switch (type)
     463                 :            :     {
     464                 :  306667000 :     case CPP_PADDING:
     465                 :  306667000 :       goto retry;
     466                 :            : 
     467                 :  927809000 :     case CPP_NAME:
     468                 :  927809000 :       *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
     469                 :  927809000 :       break;
     470                 :            : 
     471                 :   31726900 :     case CPP_NUMBER:
     472                 :   31726900 :       {
     473                 :   31726900 :         const char *suffix = NULL;
     474                 :   31726900 :         unsigned int flags = cpp_classify_number (parse_in, tok, &suffix, *loc);
     475                 :            : 
     476                 :   31726900 :         switch (flags & CPP_N_CATEGORY)
     477                 :            :           {
     478                 :        162 :           case CPP_N_INVALID:
     479                 :            :             /* cpplib has issued an error.  */
     480                 :        162 :             *value = error_mark_node;
     481                 :        162 :             break;
     482                 :            : 
     483                 :   30646700 :           case CPP_N_INTEGER:
     484                 :            :             /* C++ uses '0' to mark virtual functions as pure.
     485                 :            :                Set PURE_ZERO to pass this information to the C++ parser.  */
     486                 :   30646700 :             if (tok->val.str.len == 1 && *tok->val.str.text == '0')
     487                 :    6389220 :               add_flags = PURE_ZERO;
     488                 :   30646700 :             *value = interpret_integer (tok, flags, &overflow);
     489                 :   30646700 :             break;
     490                 :            : 
     491                 :    1080070 :           case CPP_N_FLOATING:
     492                 :    1080070 :             *value = interpret_float (tok, flags, suffix, &overflow);
     493                 :    1080070 :             break;
     494                 :            : 
     495                 :          0 :           default:
     496                 :          0 :             gcc_unreachable ();
     497                 :            :           }
     498                 :            : 
     499                 :   31726900 :         if (flags & CPP_N_USERDEF)
     500                 :            :           {
     501                 :      32052 :             char *str;
     502                 :      32052 :             tree literal;
     503                 :      32052 :             tree suffix_id = get_identifier (suffix);
     504                 :      32052 :             int len = tok->val.str.len - strlen (suffix);
     505                 :            :             /* If this is going to be used as a C string to pass to a
     506                 :            :                raw literal operator, we need to add a trailing NUL.  */
     507                 :      64104 :             tree num_string = build_string (len + 1,
     508                 :      32052 :                                             (const char *) tok->val.str.text);
     509                 :      32052 :             TREE_TYPE (num_string) = char_array_type_node;
     510                 :      32052 :             num_string = fix_string_type (num_string);
     511                 :      32052 :             str = CONST_CAST (char *, TREE_STRING_POINTER (num_string));
     512                 :      32052 :             str[len] = '\0';
     513                 :      32052 :             literal = build_userdef_literal (suffix_id, *value, overflow,
     514                 :            :                                              num_string);
     515                 :      32052 :             *value = literal;
     516                 :            :           }
     517                 :            :       }
     518                 :   31726900 :       break;
     519                 :            : 
     520                 :          4 :     case CPP_ATSIGN:
     521                 :            :       /* An @ may give the next token special significance in Objective-C.  */
     522                 :          4 :       if (c_dialect_objc ())
     523                 :            :         {
     524                 :          0 :           location_t atloc = *loc;
     525                 :          0 :           location_t newloc;
     526                 :            : 
     527                 :          0 :         retry_at:
     528                 :          0 :           tok = cpp_get_token_with_location (parse_in, &newloc);
     529                 :          0 :           type = tok->type;
     530                 :          0 :           switch (type)
     531                 :            :             {
     532                 :          0 :             case CPP_PADDING:
     533                 :          0 :               goto retry_at;
     534                 :            : 
     535                 :          0 :             case CPP_STRING:
     536                 :          0 :             case CPP_WSTRING:
     537                 :          0 :             case CPP_STRING16:
     538                 :          0 :             case CPP_STRING32:
     539                 :          0 :             case CPP_UTF8STRING:
     540                 :          0 :               type = lex_string (tok, value, true, true);
     541                 :          0 :               break;
     542                 :            : 
     543                 :          0 :             case CPP_NAME:
     544                 :          0 :               *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
     545                 :          0 :               if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value))
     546                 :          0 :                   || OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value)))
     547                 :            :                 {
     548                 :            :                   type = CPP_AT_NAME;
     549                 :            :                   /* Note the complication: if we found an OBJC_CXX
     550                 :            :                      keyword, for example, 'class', we will be
     551                 :            :                      returning a token of type CPP_AT_NAME and rid
     552                 :            :                      code RID_CLASS (not RID_AT_CLASS).  The language
     553                 :            :                      parser needs to convert that to RID_AT_CLASS.
     554                 :            :                   */
     555                 :            :                   break;
     556                 :            :                 }
     557                 :            :               /* FALLTHROUGH */
     558                 :            : 
     559                 :          0 :             default:
     560                 :            :               /* ... or not.  */
     561                 :          0 :               error_at (atloc, "stray %<@%> in program");
     562                 :          0 :               *loc = newloc;
     563                 :          0 :               goto retry_after_at;
     564                 :            :             }
     565                 :          0 :           break;
     566                 :            :         }
     567                 :            : 
     568                 :            :       /* FALLTHROUGH */
     569                 :         28 :     case CPP_HASH:
     570                 :         28 :     case CPP_PASTE:
     571                 :         28 :       {
     572                 :         28 :         unsigned char name[8];
     573                 :            : 
     574                 :         28 :         *cpp_spell_token (parse_in, tok, name, true) = 0;
     575                 :            : 
     576                 :         28 :         error_at (*loc, "stray %qs in program", name);
     577                 :            :       }
     578                 :            : 
     579                 :         28 :       goto retry;
     580                 :            : 
     581                 :         76 :     case CPP_OTHER:
     582                 :         76 :       {
     583                 :         76 :         cppchar_t c = tok->val.str.text[0];
     584                 :            : 
     585                 :         76 :         if (c == '"' || c == '\'')
     586                 :         19 :           error_at (*loc, "missing terminating %c character", (int) c);
     587                 :         57 :         else if (ISGRAPH (c))
     588                 :         49 :           error_at (*loc, "stray %qc in program", (int) c);
     589                 :            :         else
     590                 :          8 :           error_at (*loc, "stray %<\\%o%> in program", (int) c);
     591                 :            :       }
     592                 :         76 :       goto retry;
     593                 :            : 
     594                 :        109 :     case CPP_CHAR_USERDEF:
     595                 :        109 :     case CPP_WCHAR_USERDEF:
     596                 :        109 :     case CPP_CHAR16_USERDEF:
     597                 :        109 :     case CPP_CHAR32_USERDEF:
     598                 :        109 :     case CPP_UTF8CHAR_USERDEF:
     599                 :        109 :       {
     600                 :        109 :         tree literal;
     601                 :        109 :         cpp_token temp_tok = *tok;
     602                 :        109 :         const char *suffix = cpp_get_userdef_suffix (tok);
     603                 :        109 :         temp_tok.val.str.len -= strlen (suffix);
     604                 :        109 :         temp_tok.type = cpp_userdef_char_remove_type (type);
     605                 :        109 :         literal = build_userdef_literal (get_identifier (suffix),
     606                 :            :                                          lex_charconst (&temp_tok),
     607                 :            :                                          OT_NONE, NULL_TREE);
     608                 :        109 :         *value = literal;
     609                 :            :       }
     610                 :        109 :       break;
     611                 :            : 
     612                 :     224997 :     case CPP_CHAR:
     613                 :     224997 :     case CPP_WCHAR:
     614                 :     224997 :     case CPP_CHAR16:
     615                 :     224997 :     case CPP_CHAR32:
     616                 :     224997 :     case CPP_UTF8CHAR:
     617                 :     224997 :       *value = lex_charconst (tok);
     618                 :     224997 :       break;
     619                 :            : 
     620                 :      20787 :     case CPP_STRING_USERDEF:
     621                 :      20787 :     case CPP_WSTRING_USERDEF:
     622                 :      20787 :     case CPP_STRING16_USERDEF:
     623                 :      20787 :     case CPP_STRING32_USERDEF:
     624                 :      20787 :     case CPP_UTF8STRING_USERDEF:
     625                 :      20787 :       {
     626                 :      20787 :         tree literal, string;
     627                 :      20787 :         const char *suffix = cpp_get_userdef_suffix (tok);
     628                 :      41574 :         string = build_string (tok->val.str.len - strlen (suffix),
     629                 :      20787 :                                (const char *) tok->val.str.text);
     630                 :      20787 :         literal = build_userdef_literal (get_identifier (suffix),
     631                 :            :                                          string, OT_NONE, NULL_TREE);
     632                 :      20787 :         *value = literal;
     633                 :            :       }
     634                 :      20787 :       break;
     635                 :            : 
     636                 :   31696000 :     case CPP_STRING:
     637                 :   31696000 :     case CPP_WSTRING:
     638                 :   31696000 :     case CPP_STRING16:
     639                 :   31696000 :     case CPP_STRING32:
     640                 :   31696000 :     case CPP_UTF8STRING:
     641                 :   31696000 :       if ((lex_flags & C_LEX_STRING_NO_JOIN) == 0)
     642                 :            :         {
     643                 :          9 :           type = lex_string (tok, value, false,
     644                 :          9 :                              (lex_flags & C_LEX_STRING_NO_TRANSLATE) == 0);
     645                 :          9 :           break;
     646                 :            :         }
     647                 :   31696000 :       *value = build_string (tok->val.str.len, (const char *) tok->val.str.text);
     648                 :   31696000 :       break;
     649                 :            : 
     650                 :    1045780 :     case CPP_PRAGMA:
     651                 :    1045780 :       *value = build_int_cst (integer_type_node, tok->val.pragma);
     652                 :    1045780 :       break;
     653                 :            : 
     654                 :            :       /* These tokens should not be visible outside cpplib.  */
     655                 :          0 :     case CPP_HEADER_NAME:
     656                 :          0 :     case CPP_MACRO_ARG:
     657                 :          0 :       gcc_unreachable ();
     658                 :            : 
     659                 :            :     /* CPP_COMMENT will appear when compiling with -C.  Ignore, except
     660                 :            :        when it is a FALLTHROUGH comment, in that case set
     661                 :            :        PREV_FALLTHROUGH flag on the next non-comment token.  */
     662                 :        410 :     case CPP_COMMENT:
     663                 :        410 :       if (tok->flags & PREV_FALLTHROUGH)
     664                 :            :         {
     665                 :        210 :           do
     666                 :            :             {
     667                 :        210 :               tok = cpp_get_token_with_location (parse_in, loc);
     668                 :        210 :               type = tok->type;
     669                 :            :             }
     670                 :        210 :           while (type == CPP_PADDING || type == CPP_COMMENT);
     671                 :        180 :           add_flags |= PREV_FALLTHROUGH;
     672                 :        180 :           goto retry_after_at;
     673                 :            :         }
     674                 :        230 :        goto retry;
     675                 :            : 
     676                 : 1039610000 :     default:
     677                 : 1039610000 :       *value = NULL_TREE;
     678                 : 1039610000 :       break;
     679                 :            :     }
     680                 :            : 
     681                 : 2032130000 :   if (cpp_flags)
     682                 : 2032130000 :     *cpp_flags = tok->flags | add_flags;
     683                 :            : 
     684                 : 2032130000 :   timevar_pop (TV_CPP);
     685                 :            : 
     686                 : 2032130000 :   return type;
     687                 :            : }
     688                 :            : 
     689                 :            : /* Returns the narrowest C-visible unsigned type, starting with the
     690                 :            :    minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
     691                 :            :    there isn't one.  */
     692                 :            : 
     693                 :            : static enum integer_type_kind
     694                 :   30646700 : narrowest_unsigned_type (const widest_int &val, unsigned int flags)
     695                 :            : {
     696                 :   30646700 :   int itk;
     697                 :            : 
     698                 :   30646700 :   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
     699                 :            :     itk = itk_unsigned_int;
     700                 :    1095430 :   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
     701                 :            :     itk = itk_unsigned_long;
     702                 :            :   else
     703                 :     747781 :     itk = itk_unsigned_long_long;
     704                 :            : 
     705                 :   30674200 :   for (; itk < itk_none; itk += 2 /* skip unsigned types */)
     706                 :            :     {
     707                 :   30674200 :       tree upper;
     708                 :            : 
     709                 :   30674200 :       if (integer_types[itk] == NULL_TREE)
     710                 :          0 :         continue;
     711                 :   30674200 :       upper = TYPE_MAX_VALUE (integer_types[itk]);
     712                 :            : 
     713                 :   30674200 :       if (wi::geu_p (wi::to_widest (upper), val))
     714                 :   30646700 :         return (enum integer_type_kind) itk;
     715                 :            :     }
     716                 :            : 
     717                 :            :   return itk_none;
     718                 :            : }
     719                 :            : 
     720                 :            : /* Ditto, but narrowest signed type.  */
     721                 :            : static enum integer_type_kind
     722                 :   29762700 : narrowest_signed_type (const widest_int &val, unsigned int flags)
     723                 :            : {
     724                 :   29762700 :   int itk;
     725                 :            : 
     726                 :   29762700 :   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
     727                 :            :     itk = itk_int;
     728                 :     343914 :   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
     729                 :            :     itk = itk_long;
     730                 :            :   else
     731                 :     174804 :     itk = itk_long_long;
     732                 :            : 
     733                 :   29824700 :   for (; itk < itk_none; itk += 2 /* skip signed types */)
     734                 :            :     {
     735                 :   29824600 :       tree upper;
     736                 :            : 
     737                 :   29824600 :       if (integer_types[itk] == NULL_TREE)
     738                 :        280 :         continue;
     739                 :   29824400 :       upper = TYPE_MAX_VALUE (integer_types[itk]);
     740                 :            : 
     741                 :   29824400 :       if (wi::geu_p (wi::to_widest (upper), val))
     742                 :   29762600 :         return (enum integer_type_kind) itk;
     743                 :            :     }
     744                 :            : 
     745                 :            :   return itk_none;
     746                 :            : }
     747                 :            : 
     748                 :            : /* Interpret TOKEN, an integer with FLAGS as classified by cpplib.  */
     749                 :            : static tree
     750                 :   30646700 : interpret_integer (const cpp_token *token, unsigned int flags,
     751                 :            :                    enum overflow_type *overflow)
     752                 :            : {
     753                 :   30646700 :   tree value, type;
     754                 :   30646700 :   enum integer_type_kind itk;
     755                 :   30646700 :   cpp_num integer;
     756                 :   30646700 :   HOST_WIDE_INT ival[3];
     757                 :            : 
     758                 :   30646700 :   *overflow = OT_NONE;
     759                 :            : 
     760                 :   30646700 :   integer = cpp_interpret_integer (parse_in, token, flags);
     761                 :   30646700 :   if (integer.overflow)
     762                 :         20 :     *overflow = OT_OVERFLOW;
     763                 :            : 
     764                 :   30646700 :   ival[0] = integer.low;
     765                 :   30646700 :   ival[1] = integer.high;
     766                 :   30646700 :   ival[2] = 0;
     767                 :   30646700 :   widest_int wval = widest_int::from_array (ival, 3);
     768                 :            : 
     769                 :            :   /* The type of a constant with a U suffix is straightforward.  */
     770                 :   30646700 :   if (flags & CPP_N_UNSIGNED)
     771                 :     883978 :     itk = narrowest_unsigned_type (wval, flags);
     772                 :            :   else
     773                 :            :     {
     774                 :            :       /* The type of a potentially-signed integer constant varies
     775                 :            :          depending on the base it's in, the standard in use, and the
     776                 :            :          length suffixes.  */
     777                 :   29762700 :       enum integer_type_kind itk_u
     778                 :   29762700 :         = narrowest_unsigned_type (wval, flags);
     779                 :   29762700 :       enum integer_type_kind itk_s
     780                 :   29762700 :         = narrowest_signed_type (wval, flags);
     781                 :            : 
     782                 :            :       /* In both C89 and C99, octal and hex constants may be signed or
     783                 :            :          unsigned, whichever fits tighter.  We do not warn about this
     784                 :            :          choice differing from the traditional choice, as the constant
     785                 :            :          is probably a bit pattern and either way will work.  */
     786                 :   29762700 :       if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
     787                 :    3411840 :         itk = MIN (itk_u, itk_s);
     788                 :            :       else
     789                 :            :         {
     790                 :            :           /* In C99, decimal constants are always signed.
     791                 :            :              In C89, decimal constants that don't fit in long have
     792                 :            :              undefined behavior; we try to make them unsigned long.
     793                 :            :              In GCC's extended C89, that last is true of decimal
     794                 :            :              constants that don't fit in long long, too.  */
     795                 :            : 
     796                 :   26350900 :           itk = itk_s;
     797                 :   26350900 :           if (itk_s > itk_u && itk_s > itk_long)
     798                 :            :             {
     799                 :         25 :               if (!flag_isoc99)
     800                 :            :                 {
     801                 :         16 :                   if (itk_u < itk_unsigned_long)
     802                 :          0 :                     itk_u = itk_unsigned_long;
     803                 :         16 :                   itk = itk_u;
     804                 :         16 :                   warning (0, "this decimal constant is unsigned only in ISO C90");
     805                 :            :                 }
     806                 :            :               else
     807                 :          9 :                 warning (OPT_Wtraditional,
     808                 :            :                          "this decimal constant would be unsigned in ISO C90");
     809                 :            :             }
     810                 :            :         }
     811                 :            :     }
     812                 :            : 
     813                 :   30646700 :   if (itk == itk_none)
     814                 :            :     /* cpplib has already issued a warning for overflow.  */
     815                 :          0 :     type = ((flags & CPP_N_UNSIGNED)
     816                 :          0 :             ? widest_unsigned_literal_type_node
     817                 :            :             : widest_integer_literal_type_node);
     818                 :            :   else
     819                 :            :     {
     820                 :   30646700 :       type = integer_types[itk];
     821                 :   30646700 :       if (itk > itk_unsigned_long
     822                 :     748089 :           && (flags & CPP_N_WIDTH) != CPP_N_LARGE)
     823                 :        308 :         emit_diagnostic
     824                 :        924 :           ((c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99)
     825                 :            :            ? DK_PEDWARN : DK_WARNING,
     826                 :            :            input_location, OPT_Wlong_long,
     827                 :            :            (flags & CPP_N_UNSIGNED)
     828                 :            :            ? "integer constant is too large for %<unsigned long%> type"
     829                 :            :            : "integer constant is too large for %<long%> type");
     830                 :            :     }
     831                 :            : 
     832                 :   30646700 :   value = wide_int_to_tree (type, wval);
     833                 :            : 
     834                 :            :   /* Convert imaginary to a complex type.  */
     835                 :   30646700 :   if (flags & CPP_N_IMAGINARY)
     836                 :       3079 :     value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
     837                 :            : 
     838                 :   30646700 :   return value;
     839                 :            : }
     840                 :            : 
     841                 :            : /* Interpret TOKEN, a floating point number with FLAGS as classified
     842                 :            :    by cpplib.  For C++11 SUFFIX may contain a user-defined literal suffix.  */
     843                 :            : static tree
     844                 :    1080070 : interpret_float (const cpp_token *token, unsigned int flags,
     845                 :            :                  const char *suffix, enum overflow_type *overflow)
     846                 :            : {
     847                 :    1080070 :   tree type;
     848                 :    1080070 :   tree const_type;
     849                 :    1080070 :   tree value;
     850                 :    1080070 :   REAL_VALUE_TYPE real;
     851                 :    1080070 :   REAL_VALUE_TYPE real_trunc;
     852                 :    1080070 :   char *copy;
     853                 :    1080070 :   size_t copylen;
     854                 :            : 
     855                 :    1080070 :   *overflow = OT_NONE;
     856                 :            : 
     857                 :            :   /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
     858                 :            :      pragma has been used and is either double or _Decimal64.  Types
     859                 :            :      that are not allowed with decimal float default to double.  */
     860                 :    1080070 :   if (flags & CPP_N_DEFAULT)
     861                 :            :     {
     862                 :     703270 :       flags ^= CPP_N_DEFAULT;
     863                 :     703270 :       flags |= CPP_N_MEDIUM;
     864                 :            : 
     865                 :     703270 :       if (((flags & CPP_N_HEX) == 0) && ((flags & CPP_N_IMAGINARY) == 0))
     866                 :            :         {
     867                 :     690479 :           warning (OPT_Wunsuffixed_float_constants,
     868                 :            :                    "unsuffixed floating constant");
     869                 :     690479 :           if (float_const_decimal64_p ())
     870                 :         23 :             flags |= CPP_N_DFLOAT;
     871                 :            :         }
     872                 :            :     }
     873                 :            : 
     874                 :            :   /* Decode _Fract and _Accum.  */
     875                 :    1080070 :   if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
     876                 :         57 :     return interpret_fixed (token, flags);
     877                 :            : 
     878                 :            :   /* Decode type based on width and properties. */
     879                 :    1080020 :   if (flags & CPP_N_DFLOAT)
     880                 :      16040 :     if (!targetm.decimal_float_supported_p ())
     881                 :            :       {
     882                 :          0 :         error ("decimal floating-point not supported for this target");
     883                 :          0 :         return error_mark_node;
     884                 :            :       }
     885                 :      16040 :     else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
     886                 :       5092 :       type = dfloat128_type_node;
     887                 :      10948 :     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
     888                 :       5539 :       type = dfloat32_type_node;
     889                 :            :     else
     890                 :       5409 :       type = dfloat64_type_node;
     891                 :            :   else
     892                 :    1063980 :     if (flags & CPP_N_WIDTH_MD)
     893                 :            :       {
     894                 :      16870 :         char suffix;
     895                 :      16870 :         machine_mode mode;
     896                 :            : 
     897                 :      16870 :         if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
     898                 :            :           suffix = 'w';
     899                 :            :         else
     900                 :      16825 :           suffix = 'q';
     901                 :            : 
     902                 :      16870 :         mode = targetm.c.mode_for_suffix (suffix);
     903                 :      16870 :         if (mode == VOIDmode)
     904                 :            :           {
     905                 :          0 :             error ("unsupported non-standard suffix on floating constant");
     906                 :            : 
     907                 :          0 :             return error_mark_node;
     908                 :            :           }
     909                 :            :         else
     910                 :      16870 :           pedwarn (input_location, OPT_Wpedantic, "non-standard suffix on floating constant");
     911                 :            : 
     912                 :      16870 :         type = c_common_type_for_mode (mode, 0);
     913                 :      16870 :         gcc_assert (type);
     914                 :            :       }
     915                 :    1047100 :     else if ((flags & (CPP_N_FLOATN | CPP_N_FLOATNX)) != 0)
     916                 :            :       {
     917                 :       3612 :         unsigned int n = (flags & CPP_N_WIDTH_FLOATN_NX) >> CPP_FLOATN_SHIFT;
     918                 :       3612 :         bool extended = (flags & CPP_N_FLOATNX) != 0;
     919                 :       3612 :         type = NULL_TREE;
     920                 :      14000 :         for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
     921                 :      14000 :           if (floatn_nx_types[i].n == (int) n
     922                 :       4932 :               && floatn_nx_types[i].extended == extended)
     923                 :            :             {
     924                 :       3612 :               type = FLOATN_NX_TYPE_NODE (i);
     925                 :       3612 :               break;
     926                 :            :             }
     927                 :       3612 :         if (type == NULL_TREE)
     928                 :            :           {
     929                 :          0 :             error ("unsupported non-standard suffix on floating constant");
     930                 :          0 :             return error_mark_node;
     931                 :            :           }
     932                 :            :         else
     933                 :       3612 :           pedwarn (input_location, OPT_Wpedantic, "non-standard suffix on floating constant");
     934                 :            :       }
     935                 :    1043490 :     else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
     936                 :     165114 :       type = long_double_type_node;
     937                 :     878379 :     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
     938                 :     703344 :              || flag_single_precision_constant)
     939                 :     175213 :       type = float_type_node;
     940                 :            :     else
     941                 :     703166 :       type = double_type_node;
     942                 :            : 
     943                 :    1080020 :   const_type = excess_precision_type (type);
     944                 :    1080020 :   if (!const_type)
     945                 :    1079920 :     const_type = type;
     946                 :            : 
     947                 :            :   /* Copy the constant to a nul-terminated buffer.  If the constant
     948                 :            :      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
     949                 :            :      can't handle them.  */
     950                 :    1080020 :   copylen = token->val.str.len;
     951                 :    1080020 :   if (flags & CPP_N_USERDEF)
     952                 :      31706 :     copylen -= strlen (suffix);
     953                 :    1048310 :   else if (flags & CPP_N_DFLOAT)
     954                 :      16040 :     copylen -= 2;
     955                 :            :   else
     956                 :            :     {
     957                 :    1032270 :       if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
     958                 :            :         /* Must be an F or L or machine defined suffix.  */
     959                 :     328925 :         copylen--;
     960                 :    1032270 :       if (flags & CPP_N_IMAGINARY)
     961                 :            :         /* I or J suffix.  */
     962                 :      50878 :         copylen--;
     963                 :    1032270 :       if (flags & CPP_N_FLOATNX)
     964                 :       1320 :         copylen--;
     965                 :    1032270 :       if (flags & (CPP_N_FLOATN | CPP_N_FLOATNX))
     966                 :            :         {
     967                 :       3612 :           unsigned int n = (flags & CPP_N_WIDTH_FLOATN_NX) >> CPP_FLOATN_SHIFT;
     968                 :      11584 :           while (n > 0)
     969                 :            :             {
     970                 :       7972 :               copylen--;
     971                 :       7972 :               n /= 10;
     972                 :            :             }
     973                 :            :         }
     974                 :            :     }
     975                 :            : 
     976                 :    1080020 :   copy = (char *) alloca (copylen + 1);
     977                 :    1080020 :   if (cxx_dialect > cxx11)
     978                 :            :     {
     979                 :            :       size_t maxlen = 0;
     980                 :    4869800 :       for (size_t i = 0; i < copylen; ++i)
     981                 :    4460610 :         if (token->val.str.text[i] != '\'')
     982                 :    4460580 :           copy[maxlen++] = token->val.str.text[i];
     983                 :     409189 :       copy[maxlen] = '\0';
     984                 :            :     }
     985                 :            :   else
     986                 :            :     {
     987                 :     670826 :       memcpy (copy, token->val.str.text, copylen);
     988                 :     670826 :       copy[copylen] = '\0';
     989                 :            :     }
     990                 :            : 
     991                 :    1080020 :   real_from_string3 (&real, copy, TYPE_MODE (const_type));
     992                 :    1080020 :   if (const_type != type)
     993                 :            :     /* Diagnosing if the result of converting the value with excess
     994                 :            :        precision to the semantic type would overflow (with associated
     995                 :            :        double rounding) is more appropriate than diagnosing if the
     996                 :            :        result of converting the string directly to the semantic type
     997                 :            :        would overflow.  */
     998                 :         90 :     real_convert (&real_trunc, TYPE_MODE (type), &real);
     999                 :            : 
    1000                 :            :   /* Both C and C++ require a diagnostic for a floating constant
    1001                 :            :      outside the range of representable values of its type.  Since we
    1002                 :            :      have __builtin_inf* to produce an infinity, this is now a
    1003                 :            :      mandatory pedwarn if the target does not support infinities.  */
    1004                 :    1080020 :   if (REAL_VALUE_ISINF (real)
    1005                 :    1080020 :       || (const_type != type && REAL_VALUE_ISINF (real_trunc)))
    1006                 :            :     {
    1007                 :         56 :       *overflow = OT_OVERFLOW;
    1008                 :         56 :       if (!(flags & CPP_N_USERDEF))
    1009                 :            :         {
    1010                 :        319 :           if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
    1011                 :          0 :             pedwarn (input_location, 0,
    1012                 :            :                      "floating constant exceeds range of %qT", type);
    1013                 :            :           else
    1014                 :         47 :             warning (OPT_Woverflow,
    1015                 :            :                      "floating constant exceeds range of %qT", type);
    1016                 :            :         }
    1017                 :            :     }
    1018                 :            :   /* We also give a warning if the value underflows.  */
    1019                 :    1079960 :   else if (real_equal (&real, &dconst0)
    1020                 :    1079960 :            || (const_type != type
    1021                 :         72 :                && real_equal (&real_trunc, &dconst0)))
    1022                 :            :     {
    1023                 :     426118 :       REAL_VALUE_TYPE realvoidmode;
    1024                 :     426118 :       int oflow = real_from_string (&realvoidmode, copy);
    1025                 :     426118 :       *overflow = (oflow == 0 ? OT_NONE
    1026                 :         21 :                               : (oflow < 0 ? OT_UNDERFLOW : OT_OVERFLOW));
    1027                 :     426118 :       if (!(flags & CPP_N_USERDEF))
    1028                 :            :         {
    1029                 :     394597 :           if (oflow < 0 || !real_equal (&realvoidmode, &dconst0))
    1030                 :         30 :             warning (OPT_Woverflow, "floating constant truncated to zero");
    1031                 :            :         }
    1032                 :            :     }
    1033                 :            : 
    1034                 :            :   /* Create a node with determined type and value.  */
    1035                 :    1080020 :   value = build_real (const_type, real);
    1036                 :    1080020 :   if (flags & CPP_N_IMAGINARY)
    1037                 :            :     {
    1038                 :      50878 :       value = build_complex (NULL_TREE,
    1039                 :            :                              fold_convert (const_type,
    1040                 :            :                                            integer_zero_node), value);
    1041                 :      50878 :       if (type != const_type)
    1042                 :            :         {
    1043                 :          6 :           const_type = TREE_TYPE (value);
    1044                 :          6 :           type = build_complex_type (type);
    1045                 :            :         }
    1046                 :            :     }
    1047                 :            : 
    1048                 :    1080020 :   if (type != const_type)
    1049                 :         90 :     value = build1_loc (token->src_loc, EXCESS_PRECISION_EXPR, type, value);
    1050                 :            : 
    1051                 :            :   return value;
    1052                 :            : }
    1053                 :            : 
    1054                 :            : /* Interpret TOKEN, a fixed-point number with FLAGS as classified
    1055                 :            :    by cpplib.  */
    1056                 :            : 
    1057                 :            : static tree
    1058                 :         57 : interpret_fixed (const cpp_token *token, unsigned int flags)
    1059                 :            : {
    1060                 :         57 :   tree type;
    1061                 :         57 :   tree value;
    1062                 :         57 :   FIXED_VALUE_TYPE fixed;
    1063                 :         57 :   char *copy;
    1064                 :         57 :   size_t copylen;
    1065                 :            : 
    1066                 :         57 :   copylen = token->val.str.len;
    1067                 :            : 
    1068                 :         57 :   if (flags & CPP_N_FRACT) /* _Fract.  */
    1069                 :            :     {
    1070                 :         43 :       if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract.  */
    1071                 :            :         {
    1072                 :          0 :           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
    1073                 :            :             {
    1074                 :          0 :               type = unsigned_long_long_fract_type_node;
    1075                 :          0 :               copylen -= 4;
    1076                 :            :             }
    1077                 :          0 :           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
    1078                 :            :             {
    1079                 :          0 :               type = unsigned_long_fract_type_node;
    1080                 :          0 :               copylen -= 3;
    1081                 :            :             }
    1082                 :          0 :           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
    1083                 :            :             {
    1084                 :          0 :               type = unsigned_short_fract_type_node;
    1085                 :          0 :               copylen -= 3;
    1086                 :            :             }
    1087                 :            :           else
    1088                 :            :             {
    1089                 :          0 :               type = unsigned_fract_type_node;
    1090                 :          0 :               copylen -= 2;
    1091                 :            :             }
    1092                 :            :         }
    1093                 :            :       else /* Signed _Fract.  */
    1094                 :            :         {
    1095                 :         43 :           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
    1096                 :            :             {
    1097                 :          0 :               type = long_long_fract_type_node;
    1098                 :          0 :               copylen -= 3;
    1099                 :            :             }
    1100                 :         43 :           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
    1101                 :            :             {
    1102                 :          0 :               type = long_fract_type_node;
    1103                 :          0 :               copylen -= 2;
    1104                 :            :             }
    1105                 :         43 :           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
    1106                 :            :             {
    1107                 :          0 :               type = short_fract_type_node;
    1108                 :          0 :               copylen -= 2;
    1109                 :            :             }
    1110                 :            :           else
    1111                 :            :             {
    1112                 :         43 :               type = fract_type_node;
    1113                 :         43 :               copylen --;
    1114                 :            :             }
    1115                 :            :           }
    1116                 :            :     }
    1117                 :            :   else /* _Accum.  */
    1118                 :            :     {
    1119                 :         14 :       if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum.  */
    1120                 :            :         {
    1121                 :          0 :           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
    1122                 :            :             {
    1123                 :          0 :               type = unsigned_long_long_accum_type_node;
    1124                 :          0 :               copylen -= 4;
    1125                 :            :             }
    1126                 :          0 :           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
    1127                 :            :             {
    1128                 :          0 :               type = unsigned_long_accum_type_node;
    1129                 :          0 :               copylen -= 3;
    1130                 :            :             }
    1131                 :          0 :           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
    1132                 :            :             {
    1133                 :          0 :               type = unsigned_short_accum_type_node;
    1134                 :          0 :               copylen -= 3;
    1135                 :            :              }
    1136                 :            :           else
    1137                 :            :             {
    1138                 :          0 :               type = unsigned_accum_type_node;
    1139                 :          0 :               copylen -= 2;
    1140                 :            :             }
    1141                 :            :         }
    1142                 :            :       else /* Signed _Accum.  */
    1143                 :            :         {
    1144                 :         14 :           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
    1145                 :            :             {
    1146                 :          0 :               type = long_long_accum_type_node;
    1147                 :          0 :               copylen -= 3;
    1148                 :            :             }
    1149                 :         14 :           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
    1150                 :            :             {
    1151                 :          0 :               type = long_accum_type_node;
    1152                 :          0 :               copylen -= 2;
    1153                 :            :             }
    1154                 :         14 :           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
    1155                 :            :             {
    1156                 :          0 :               type = short_accum_type_node;
    1157                 :          0 :               copylen -= 2;
    1158                 :            :             }
    1159                 :            :           else
    1160                 :            :             {
    1161                 :         14 :               type = accum_type_node;
    1162                 :         14 :               copylen --;
    1163                 :            :             }
    1164                 :            :         }
    1165                 :            :     }
    1166                 :            : 
    1167                 :         57 :   copy = (char *) alloca (copylen + 1);
    1168                 :         57 :   memcpy (copy, token->val.str.text, copylen);
    1169                 :         57 :   copy[copylen] = '\0';
    1170                 :            : 
    1171                 :         57 :   fixed_from_string (&fixed, copy, SCALAR_TYPE_MODE (type));
    1172                 :            : 
    1173                 :            :   /* Create a node with determined type and value.  */
    1174                 :         57 :   value = build_fixed (type, fixed);
    1175                 :            : 
    1176                 :         57 :   return value;
    1177                 :            : }
    1178                 :            : 
    1179                 :            : /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
    1180                 :            :    UTF8STRING tokens into a tree, performing string constant
    1181                 :            :    concatenation.  TOK is the first of these.  VALP is the location to
    1182                 :            :    write the string into.  OBJC_STRING indicates whether an '@' token
    1183                 :            :    preceded the incoming token (in that case, the strings can either
    1184                 :            :    be ObjC strings, preceded by a single '@', or normal strings, not
    1185                 :            :    preceded by '@'.  The result will be a CPP_OBJC_STRING).  Returns
    1186                 :            :    the CPP token type of the result (CPP_STRING, CPP_WSTRING,
    1187                 :            :    CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
    1188                 :            : 
    1189                 :            :    This is unfortunately more work than it should be.  If any of the
    1190                 :            :    strings in the series has an L prefix, the result is a wide string
    1191                 :            :    (6.4.5p4).  Whether or not the result is a wide string affects the
    1192                 :            :    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
    1193                 :            :    sequences do not continue across the boundary between two strings in
    1194                 :            :    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
    1195                 :            :    cpp_interpret_string takes a vector of cpp_string structures, which
    1196                 :            :    we must arrange to provide.  */
    1197                 :            : 
    1198                 :            : static enum cpp_ttype
    1199                 :          9 : lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
    1200                 :            : {
    1201                 :          9 :   tree value;
    1202                 :          9 :   size_t concats = 0;
    1203                 :          9 :   struct obstack str_ob;
    1204                 :          9 :   struct obstack loc_ob;
    1205                 :          9 :   cpp_string istr;
    1206                 :          9 :   enum cpp_ttype type = tok->type;
    1207                 :            : 
    1208                 :            :   /* Try to avoid the overhead of creating and destroying an obstack
    1209                 :            :      for the common case of just one string.  */
    1210                 :          9 :   cpp_string str = tok->val.str;
    1211                 :          9 :   location_t init_loc = tok->src_loc;
    1212                 :          9 :   cpp_string *strs = &str;
    1213                 :          9 :   location_t *locs = NULL;
    1214                 :            : 
    1215                 :            :   /* objc_at_sign_was_seen is only used when doing Objective-C string
    1216                 :            :      concatenation.  It is 'true' if we have seen an '@' before the
    1217                 :            :      current string, and 'false' if not.  We must see exactly one or
    1218                 :            :      zero '@' before each string.  */
    1219                 :          9 :   bool objc_at_sign_was_seen = false;
    1220                 :            : 
    1221                 :          9 :  retry:
    1222                 :          9 :   tok = cpp_get_token (parse_in);
    1223                 :          9 :   switch (tok->type)
    1224                 :            :     {
    1225                 :          0 :     case CPP_PADDING:
    1226                 :          0 :       goto retry;
    1227                 :          0 :     case CPP_ATSIGN:
    1228                 :          0 :       if (objc_string)
    1229                 :            :         {
    1230                 :          0 :           if (objc_at_sign_was_seen)
    1231                 :          0 :             error ("repeated %<@%> before Objective-C string");
    1232                 :            : 
    1233                 :          0 :           objc_at_sign_was_seen = true;
    1234                 :          0 :           goto retry;
    1235                 :            :         }
    1236                 :            :       /* FALLTHROUGH */
    1237                 :            : 
    1238                 :          9 :     default:
    1239                 :          9 :       break;
    1240                 :            : 
    1241                 :          0 :     case CPP_WSTRING:
    1242                 :          0 :     case CPP_STRING16:
    1243                 :          0 :     case CPP_STRING32:
    1244                 :          0 :     case CPP_UTF8STRING:
    1245                 :          0 :       if (type != tok->type)
    1246                 :            :         {
    1247                 :          0 :           if (type == CPP_STRING)
    1248                 :          0 :             type = tok->type;
    1249                 :            :           else
    1250                 :          0 :             error ("unsupported non-standard concatenation of string literals");
    1251                 :            :         }
    1252                 :            :       /* FALLTHROUGH */
    1253                 :            : 
    1254                 :          0 :     case CPP_STRING:
    1255                 :          0 :       if (!concats)
    1256                 :            :         {
    1257                 :          0 :           gcc_obstack_init (&str_ob);
    1258                 :          0 :           gcc_obstack_init (&loc_ob);
    1259                 :          0 :           obstack_grow (&str_ob, &str, sizeof (cpp_string));
    1260                 :          0 :           obstack_grow (&loc_ob, &init_loc, sizeof (location_t));
    1261                 :            :         }
    1262                 :            : 
    1263                 :          0 :       concats++;
    1264                 :          0 :       obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
    1265                 :          0 :       obstack_grow (&loc_ob, &tok->src_loc, sizeof (location_t));
    1266                 :            : 
    1267                 :          0 :       if (objc_string)
    1268                 :          0 :         objc_at_sign_was_seen = false;
    1269                 :          0 :       goto retry;
    1270                 :            :     }
    1271                 :            : 
    1272                 :            :   /* It is an error if we saw a '@' with no following string.  */
    1273                 :          9 :   if (objc_at_sign_was_seen)
    1274                 :          0 :     error ("stray %<@%> in program");
    1275                 :            : 
    1276                 :            :   /* We have read one more token than we want.  */
    1277                 :          9 :   _cpp_backup_tokens (parse_in, 1);
    1278                 :          9 :   if (concats)
    1279                 :            :     {
    1280                 :          0 :       strs = XOBFINISH (&str_ob, cpp_string *);
    1281                 :          0 :       locs = XOBFINISH (&loc_ob, location_t *);
    1282                 :            :     }
    1283                 :            : 
    1284                 :          9 :   if (concats && !objc_string && !in_system_header_at (input_location))
    1285                 :          0 :     warning (OPT_Wtraditional,
    1286                 :            :              "traditional C rejects string constant concatenation");
    1287                 :            : 
    1288                 :          9 :   if ((translate
    1289                 :          9 :        ? cpp_interpret_string : cpp_interpret_string_notranslate)
    1290                 :          9 :       (parse_in, strs, concats + 1, &istr, type))
    1291                 :            :     {
    1292                 :          9 :       value = build_string (istr.len, (const char *) istr.text);
    1293                 :          9 :       free (CONST_CAST (unsigned char *, istr.text));
    1294                 :          9 :       if (concats)
    1295                 :            :         {
    1296                 :          0 :           gcc_assert (locs);
    1297                 :          0 :           gcc_assert (g_string_concat_db);
    1298                 :          0 :           g_string_concat_db->record_string_concatenation (concats + 1, locs);
    1299                 :            :         }
    1300                 :            :     }
    1301                 :            :   else
    1302                 :            :     {
    1303                 :            :       /* Callers cannot generally handle error_mark_node in this context,
    1304                 :            :          so return the empty string instead.  cpp_interpret_string has
    1305                 :            :          issued an error.  */
    1306                 :          0 :       switch (type)
    1307                 :            :         {
    1308                 :          0 :         default:
    1309                 :          0 :         case CPP_STRING:
    1310                 :          0 :         case CPP_UTF8STRING:
    1311                 :          0 :           value = build_string (1, "");
    1312                 :          0 :           break;
    1313                 :          0 :         case CPP_STRING16:
    1314                 :          0 :           value = build_string (TYPE_PRECISION (char16_type_node)
    1315                 :          0 :                                 / TYPE_PRECISION (char_type_node),
    1316                 :            :                                 "\0");  /* char16_t is 16 bits */
    1317                 :          0 :           break;
    1318                 :          0 :         case CPP_STRING32:
    1319                 :          0 :           value = build_string (TYPE_PRECISION (char32_type_node)
    1320                 :          0 :                                 / TYPE_PRECISION (char_type_node),
    1321                 :            :                                 "\0\0\0");  /* char32_t is 32 bits */
    1322                 :          0 :           break;
    1323                 :          0 :         case CPP_WSTRING:
    1324                 :          0 :           value = build_string (TYPE_PRECISION (wchar_type_node)
    1325                 :          0 :                                 / TYPE_PRECISION (char_type_node),
    1326                 :            :                                 "\0\0\0");  /* widest supported wchar_t
    1327                 :            :                                                is 32 bits */
    1328                 :          0 :           break;
    1329                 :            :         }
    1330                 :            :     }
    1331                 :            : 
    1332                 :          9 :   switch (type)
    1333                 :            :     {
    1334                 :          9 :     default:
    1335                 :          9 :     case CPP_STRING:
    1336                 :          9 :       TREE_TYPE (value) = char_array_type_node;
    1337                 :          9 :       break;
    1338                 :          0 :     case CPP_UTF8STRING:
    1339                 :          0 :       if (flag_char8_t)
    1340                 :          0 :         TREE_TYPE (value) = char8_array_type_node;
    1341                 :            :       else
    1342                 :          0 :         TREE_TYPE (value) = char_array_type_node;
    1343                 :            :       break;
    1344                 :          0 :     case CPP_STRING16:
    1345                 :          0 :       TREE_TYPE (value) = char16_array_type_node;
    1346                 :          0 :       break;
    1347                 :          0 :     case CPP_STRING32:
    1348                 :          0 :       TREE_TYPE (value) = char32_array_type_node;
    1349                 :          0 :       break;
    1350                 :          0 :     case CPP_WSTRING:
    1351                 :          0 :       TREE_TYPE (value) = wchar_array_type_node;
    1352                 :            :     }
    1353                 :          9 :   *valp = fix_string_type (value);
    1354                 :            : 
    1355                 :          9 :   if (concats)
    1356                 :            :     {
    1357                 :          0 :       obstack_free (&str_ob, 0);
    1358                 :          0 :       obstack_free (&loc_ob, 0);
    1359                 :            :     }
    1360                 :            : 
    1361                 :          9 :   return objc_string ? CPP_OBJC_STRING : type;
    1362                 :            : }
    1363                 :            : 
    1364                 :            : /* Converts a (possibly wide) character constant token into a tree.  */
    1365                 :            : static tree
    1366                 :     225106 : lex_charconst (const cpp_token *token)
    1367                 :            : {
    1368                 :     225106 :   cppchar_t result;
    1369                 :     225106 :   tree type, value;
    1370                 :     225106 :   unsigned int chars_seen;
    1371                 :     225106 :   int unsignedp = 0;
    1372                 :            : 
    1373                 :     225106 :   result = cpp_interpret_charconst (parse_in, token,
    1374                 :            :                                     &chars_seen, &unsignedp);
    1375                 :            : 
    1376                 :     225106 :   if (token->type == CPP_WCHAR)
    1377                 :       6397 :     type = wchar_type_node;
    1378                 :     218709 :   else if (token->type == CPP_CHAR32)
    1379                 :        203 :     type = char32_type_node;
    1380                 :     218506 :   else if (token->type == CPP_CHAR16)
    1381                 :        288 :     type = char16_type_node;
    1382                 :     218218 :   else if (token->type == CPP_UTF8CHAR)
    1383                 :            :     {
    1384                 :        100 :       if (!c_dialect_cxx ())
    1385                 :         38 :         type = unsigned_char_type_node;
    1386                 :         62 :       else if (flag_char8_t)
    1387                 :         48 :         type = char8_type_node;
    1388                 :            :       else
    1389                 :         14 :         type = char_type_node;
    1390                 :            :     }
    1391                 :            :   /* In C, a character constant has type 'int'.
    1392                 :            :      In C++ 'char', but multi-char charconsts have type 'int'.  */
    1393                 :     218118 :   else if (!c_dialect_cxx () || chars_seen > 1)
    1394                 :      49044 :     type = integer_type_node;
    1395                 :            :   else
    1396                 :     169074 :     type = char_type_node;
    1397                 :            : 
    1398                 :            :   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
    1399                 :            :      before possibly widening to HOST_WIDE_INT for build_int_cst.  */
    1400                 :     225106 :   if (unsignedp || (cppchar_signed_t) result >= 0)
    1401                 :     224898 :     value = build_int_cst (type, result);
    1402                 :            :   else
    1403                 :        208 :     value = build_int_cst (type, (cppchar_signed_t) result);
    1404                 :            : 
    1405                 :     225106 :   return value;
    1406                 :            : }
    1407                 :            : 
    1408                 :            : /* Helper function for c_parser_peek_conflict_marker
    1409                 :            :    and cp_lexer_peek_conflict_marker.
    1410                 :            :    Given a possible conflict marker token of kind TOK1_KIND
    1411                 :            :    consisting of a pair of characters, get the token kind for the
    1412                 :            :    standalone final character.  */
    1413                 :            : 
    1414                 :            : enum cpp_ttype
    1415                 :        123 : conflict_marker_get_final_tok_kind (enum cpp_ttype tok1_kind)
    1416                 :            : {
    1417                 :        123 :   switch (tok1_kind)
    1418                 :            :     {
    1419                 :          0 :     default: gcc_unreachable ();
    1420                 :            :     case CPP_LSHIFT:
    1421                 :            :       /* "<<" and '<' */
    1422                 :            :       return CPP_LESS;
    1423                 :            : 
    1424                 :         38 :     case CPP_EQ_EQ:
    1425                 :            :       /* "==" and '=' */
    1426                 :         38 :       return CPP_EQ;
    1427                 :            : 
    1428                 :         43 :     case CPP_RSHIFT:
    1429                 :            :       /* ">>" and '>' */
    1430                 :         43 :       return CPP_GREATER;
    1431                 :            :     }
    1432                 :            : }

Generated by: LCOV version 1.0

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