gcc/c-lex.c

   1 /* Mainly the interface between cpplib and the C front ends.
   2    Copyright (C) 1987, 1988, 1989, 1992, 1994, 1995, 1996, 1997
   3    1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26
  27 #include "real.h"
  28 #include "rtl.h"
  29 #include "tree.h"
  30 #include "input.h"
  31 #include "output.h"
  32 #include "c-tree.h"
  33 #include "c-common.h"
  34 #include "flags.h"
  35 #include "timevar.h"
  36 #include "cpplib.h"
  37 #include "c-pragma.h"
  38 #include "toplev.h"
  39 #include "intl.h"
  40 #include "tm_p.h"
  41 #include "splay-tree.h"
  42 #include "debug.h"
  43 #include "target.h"
  44
  45 /* We may keep statistics about how long which files took to compile.  */
  46 static int header_time, body_time;
  47 static splay_tree file_info_tree;
  48
  49 int pending_lang_change; /* If we need to switch languages - C++ only */
  50 int c_header_level;      /* depth in C headers - C++ only */
  51
  52 static tree interpret_integer (const cpp_token *, unsigned int);
  53 static tree interpret_float (const cpp_token *, unsigned int);
  54 static tree interpret_fixed (const cpp_token *, unsigned int);
  55 static enum integer_type_kind narrowest_unsigned_type
  56         (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
  57 static enum integer_type_kind narrowest_signed_type
  58         (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
  59 static enum cpp_ttype lex_string (const cpp_token *, tree *, bool, bool);
  60 static tree lex_charconst (const cpp_token *);
  61 static void update_header_times (const char *);
  62 static int dump_one_header (splay_tree_node, void *);
  63 static void cb_line_change (cpp_reader *, const cpp_token *, int);
  64 static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
  65 static void cb_def_pragma (cpp_reader *, unsigned int);
  66 static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
  67 static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
  68 \f
  69 void
  70 init_c_lex (void)
  71 {
  72   struct cpp_callbacks *cb;
  73   struct c_fileinfo *toplevel;
  74
  75   /* The get_fileinfo data structure must be initialized before
  76      cpp_read_main_file is called.  */
  77   toplevel = get_fileinfo ("<top level>");
  78   if (flag_detailed_statistics)
  79     {
  80       header_time = 0;
  81       body_time = get_run_time ();
  82       toplevel->time = body_time;
  83     }
  84
  85   cb = cpp_get_callbacks (parse_in);
  86
  87   cb->line_change = cb_line_change;
  88   cb->ident = cb_ident;
  89   cb->def_pragma = cb_def_pragma;
  90   cb->valid_pch = c_common_valid_pch;
  91   cb->read_pch = c_common_read_pch;
  92
  93   /* Set the debug callbacks if we can use them.  */
  94   if (debug_info_level == DINFO_LEVEL_VERBOSE
  95       && (write_symbols == DWARF2_DEBUG
  96           || write_symbols == VMS_AND_DWARF2_DEBUG))
  97     {
  98       cb->define = cb_define;
  99       cb->undef = cb_undef;
 100     }
 101 }
 102
 103 struct c_fileinfo *
 104 get_fileinfo (const char *name)
 105 {
 106   splay_tree_node n;
 107   struct c_fileinfo *fi;
 108
 109   if (!file_info_tree)
 110     file_info_tree = splay_tree_new ((splay_tree_compare_fn) strcmp,
 111                                      0,
 112                                      (splay_tree_delete_value_fn) free);
 113
 114   n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
 115   if (n)
 116     return (struct c_fileinfo *) n->value;
 117
 118   fi = XNEW (struct c_fileinfo);
 119   fi->time = 0;
 120   fi->interface_only = 0;
 121   fi->interface_unknown = 1;
 122   splay_tree_insert (file_info_tree, (splay_tree_key) name,
 123                      (splay_tree_value) fi);
 124   return fi;
 125 }
 126
 127 static void
 128 update_header_times (const char *name)
 129 {
 130   /* Changing files again.  This means currently collected time
 131      is charged against header time, and body time starts back at 0.  */
 132   if (flag_detailed_statistics)
 133     {
 134       int this_time = get_run_time ();
 135       struct c_fileinfo *file = get_fileinfo (name);
 136       header_time += this_time - body_time;
 137       file->time += this_time - body_time;
 138       body_time = this_time;
 139     }
 140 }
 141
 142 static int
 143 dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy))
 144 {
 145   print_time ((const char *) n->key,
 146               ((struct c_fileinfo *) n->value)->time);
 147   return 0;
 148 }
 149
 150 void
 151 dump_time_statistics (void)
 152 {
 153   struct c_fileinfo *file = get_fileinfo (input_filename);
 154   int this_time = get_run_time ();
 155   file->time += this_time - body_time;
 156
 157   fprintf (stderr, "\n******\n");
 158   print_time ("header files (total)", header_time);
 159   print_time ("main file (total)", this_time - body_time);
 160   fprintf (stderr, "ratio = %g : 1\n",
 161            (double) header_time / (double) (this_time - body_time));
 162   fprintf (stderr, "\n******\n");
 163
 164   splay_tree_foreach (file_info_tree, dump_one_header, 0);
 165 }
 166
 167 static void
 168 cb_ident (cpp_reader * ARG_UNUSED (pfile),
 169           unsigned int ARG_UNUSED (line),
 170           const cpp_string * ARG_UNUSED (str))
 171 {
 172 #ifdef ASM_OUTPUT_IDENT
 173   if (!flag_no_ident)
 174     {
 175       /* Convert escapes in the string.  */
 176       cpp_string cstr = { 0, 0 };
 177       if (cpp_interpret_string (pfile, str, 1, &cstr, CPP_STRING))
 178         {
 179           ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text);
 180           free (CONST_CAST (unsigned char *, cstr.text));
 181         }
 182     }
 183 #endif
 184 }
 185
 186 /* Called at the start of every non-empty line.  TOKEN is the first
 187    lexed token on the line.  Used for diagnostic line numbers.  */
 188 static void
 189 cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token,
 190                 int parsing_args)
 191 {
 192   if (token->type != CPP_EOF && !parsing_args)
 193     input_location = token->src_loc;
 194 }
 195
 196 void
 197 fe_file_change (const struct line_map *new_map)
 198 {
 199   if (new_map == NULL)
 200     return;
 201
 202   if (new_map->reason == LC_ENTER)
 203     {
 204       /* Don't stack the main buffer on the input stack;
 205          we already did in compile_file.  */
 206       if (!MAIN_FILE_P (new_map))
 207         {
 208           unsigned int included_at = LAST_SOURCE_LINE_LOCATION (new_map - 1);
 209           int line = 0;
 210           if (included_at > BUILTINS_LOCATION)
 211             line = SOURCE_LINE (new_map - 1, included_at);
 212
 213           input_location = new_map->start_location;
 214           (*debug_hooks->start_source_file) (line, new_map->to_file);
 215 #ifndef NO_IMPLICIT_EXTERN_C
 216           if (c_header_level)
 217             ++c_header_level;
 218           else if (new_map->sysp == 2)
 219             {
 220               c_header_level = 1;
 221               ++pending_lang_change;
 222             }
 223 #endif
 224         }
 225     }
 226   else if (new_map->reason == LC_LEAVE)
 227     {
 228 #ifndef NO_IMPLICIT_EXTERN_C
 229       if (c_header_level && --c_header_level == 0)
 230         {
 231           if (new_map->sysp == 2)
 232             warning (0, "badly nested C headers from preprocessor");
 233           --pending_lang_change;
 234         }
 235 #endif
 236       input_location = new_map->start_location;
 237
 238       (*debug_hooks->end_source_file) (new_map->to_line);
 239     }
 240
 241   update_header_times (new_map->to_file);
 242   input_location = new_map->start_location;
 243 }
 244
 245 static void
 246 cb_def_pragma (cpp_reader *pfile, source_location loc)
 247 {
 248   /* Issue a warning message if we have been asked to do so.  Ignore
 249      unknown pragmas in system headers unless an explicit
 250      -Wunknown-pragmas has been given.  */
 251   if (warn_unknown_pragmas > in_system_header)
 252     {
 253       const unsigned char *space, *name;
 254       const cpp_token *s;
 255       location_t fe_loc = loc;
 256
 257       space = name = (const unsigned char *) "";
 258       s = cpp_get_token (pfile);
 259       if (s->type != CPP_EOF)
 260         {
 261           space = cpp_token_as_text (pfile, s);
 262           s = cpp_get_token (pfile);
 263           if (s->type == CPP_NAME)
 264             name = cpp_token_as_text (pfile, s);
 265         }
 266
 267       warning (OPT_Wunknown_pragmas, "%Hignoring #pragma %s %s",
 268                &fe_loc, space, name);
 269     }
 270 }
 271
 272 /* #define callback for DWARF and DWARF2 debug info.  */
 273 static void
 274 cb_define (cpp_reader *pfile, source_location loc, cpp_hashnode *node)
 275 {
 276   const struct line_map *map = linemap_lookup (line_table, loc);
 277   (*debug_hooks->define) (SOURCE_LINE (map, loc),
 278                           (const char *) cpp_macro_definition (pfile, node));
 279 }
 280
 281 /* #undef callback for DWARF and DWARF2 debug info.  */
 282 static void
 283 cb_undef (cpp_reader * ARG_UNUSED (pfile), source_location loc,
 284           cpp_hashnode *node)
 285 {
 286   const struct line_map *map = linemap_lookup (line_table, loc);
 287   (*debug_hooks->undef) (SOURCE_LINE (map, loc),
 288                          (const char *) NODE_NAME (node));
 289 }
 290 \f
 291 /* Read a token and return its type.  Fill *VALUE with its value, if
 292    applicable.  Fill *CPP_FLAGS with the token's flags, if it is
 293    non-NULL.  */
 294
 295 enum cpp_ttype
 296 c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags,
 297                   int lex_flags)
 298 {
 299   static bool no_more_pch;
 300   const cpp_token *tok;
 301   enum cpp_ttype type;
 302   unsigned char add_flags = 0;
 303
 304   timevar_push (TV_CPP);
 305  retry:
 306   tok = cpp_get_token_with_location (parse_in, loc);
 307   type = tok->type;
 308
 309  retry_after_at:
 310   switch (type)
 311     {
 312     case CPP_PADDING:
 313       goto retry;
 314
 315     case CPP_NAME:
 316       *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
 317       break;
 318
 319     case CPP_NUMBER:
 320       {
 321         unsigned int flags = cpp_classify_number (parse_in, tok);
 322
 323         switch (flags & CPP_N_CATEGORY)
 324           {
 325           case CPP_N_INVALID:
 326             /* cpplib has issued an error.  */
 327             *value = error_mark_node;
 328             errorcount++;
 329             break;
 330
 331           case CPP_N_INTEGER:
 332             /* C++ uses '0' to mark virtual functions as pure.
 333                Set PURE_ZERO to pass this information to the C++ parser.  */
 334             if (tok->val.str.len == 1 && *tok->val.str.text == '0')
 335               add_flags = PURE_ZERO;
 336             *value = interpret_integer (tok, flags);
 337             break;
 338
 339           case CPP_N_FLOATING:
 340             *value = interpret_float (tok, flags);
 341             break;
 342
 343           default:
 344             gcc_unreachable ();
 345           }
 346       }
 347       break;
 348
 349     case CPP_ATSIGN:
 350       /* An @ may give the next token special significance in Objective-C.  */
 351       if (c_dialect_objc ())
 352         {
 353           location_t atloc = *loc;
 354           location_t newloc;
 355
 356         retry_at:
 357           tok = cpp_get_token_with_location (parse_in, &newloc);
 358           type = tok->type;
 359           switch (type)
 360             {
 361             case CPP_PADDING:
 362               goto retry_at;
 363
 364             case CPP_STRING:
 365             case CPP_WSTRING:
 366             case CPP_STRING16:
 367             case CPP_STRING32:
 368               type = lex_string (tok, value, true, true);
 369               break;
 370
 371             case CPP_NAME:
 372               *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
 373               if (objc_is_reserved_word (*value))
 374                 {
 375                   type = CPP_AT_NAME;
 376                   break;
 377                 }
 378               /* FALLTHROUGH */
 379
 380             default:
 381               /* ... or not.  */
 382               error ("%Hstray %<@%> in program", &atloc);
 383               *loc = newloc;
 384               goto retry_after_at;
 385             }
 386           break;
 387         }
 388
 389       /* FALLTHROUGH */
 390     case CPP_HASH:
 391     case CPP_PASTE:
 392       {
 393         unsigned char name[4];
 394
 395         *cpp_spell_token (parse_in, tok, name, true) = 0;
 396
 397         error ("stray %qs in program", name);
 398       }
 399
 400       goto retry;
 401
 402     case CPP_OTHER:
 403       {
 404         cppchar_t c = tok->val.str.text[0];
 405
 406         if (c == '"' || c == '\'')
 407           error ("missing terminating %c character", (int) c);
 408         else if (ISGRAPH (c))
 409           error ("stray %qc in program", (int) c);
 410         else
 411           error ("stray %<\\%o%> in program", (int) c);
 412       }
 413       goto retry;
 414
 415     case CPP_CHAR:
 416     case CPP_WCHAR:
 417     case CPP_CHAR16:
 418     case CPP_CHAR32:
 419       *value = lex_charconst (tok);
 420       break;
 421
 422     case CPP_STRING:
 423     case CPP_WSTRING:
 424     case CPP_STRING16:
 425     case CPP_STRING32:
 426       if ((lex_flags & C_LEX_RAW_STRINGS) == 0)
 427         {
 428           type = lex_string (tok, value, false,
 429                              (lex_flags & C_LEX_STRING_NO_TRANSLATE) == 0);
 430           break;
 431         }
 432       *value = build_string (tok->val.str.len, (const char *) tok->val.str.text);
 433       break;
 434
 435     case CPP_PRAGMA:
 436       *value = build_int_cst (NULL, tok->val.pragma);
 437       break;
 438
 439       /* These tokens should not be visible outside cpplib.  */
 440     case CPP_HEADER_NAME:
 441     case CPP_COMMENT:
 442     case CPP_MACRO_ARG:
 443       gcc_unreachable ();
 444
 445     default:
 446       *value = NULL_TREE;
 447       break;
 448     }
 449
 450   if (cpp_flags)
 451     *cpp_flags = tok->flags | add_flags;
 452
 453   if (!no_more_pch)
 454     {
 455       no_more_pch = true;
 456       c_common_no_more_pch ();
 457     }
 458
 459   timevar_pop (TV_CPP);
 460
 461   return type;
 462 }
 463
 464 /* Returns the narrowest C-visible unsigned type, starting with the
 465    minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
 466    there isn't one.  */
 467
 468 static enum integer_type_kind
 469 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
 470                          unsigned HOST_WIDE_INT high,
 471                          unsigned int flags)
 472 {
 473   int itk;
 474
 475   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 476     itk = itk_unsigned_int;
 477   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 478     itk = itk_unsigned_long;
 479   else
 480     itk = itk_unsigned_long_long;
 481
 482   for (; itk < itk_none; itk += 2 /* skip unsigned types */)
 483     {
 484       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
 485
 486       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
 487           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
 488               && TREE_INT_CST_LOW (upper) >= low))
 489         return (enum integer_type_kind) itk;
 490     }
 491
 492   return itk_none;
 493 }
 494
 495 /* Ditto, but narrowest signed type.  */
 496 static enum integer_type_kind
 497 narrowest_signed_type (unsigned HOST_WIDE_INT low,
 498                        unsigned HOST_WIDE_INT high, unsigned int flags)
 499 {
 500   int itk;
 501
 502   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 503     itk = itk_int;
 504   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 505     itk = itk_long;
 506   else
 507     itk = itk_long_long;
 508
 509
 510   for (; itk < itk_none; itk += 2 /* skip signed types */)
 511     {
 512       tree upper = TYPE_MAX_VALUE (integer_types[itk]);
 513
 514       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
 515           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
 516               && TREE_INT_CST_LOW (upper) >= low))
 517         return (enum integer_type_kind) itk;
 518     }
 519
 520   return itk_none;
 521 }
 522
 523 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib.  */
 524 static tree
 525 interpret_integer (const cpp_token *token, unsigned int flags)
 526 {
 527   tree value, type;
 528   enum integer_type_kind itk;
 529   cpp_num integer;
 530   cpp_options *options = cpp_get_options (parse_in);
 531
 532   integer = cpp_interpret_integer (parse_in, token, flags);
 533   integer = cpp_num_sign_extend (integer, options->precision);
 534
 535   /* The type of a constant with a U suffix is straightforward.  */
 536   if (flags & CPP_N_UNSIGNED)
 537     itk = narrowest_unsigned_type (integer.low, integer.high, flags);
 538   else
 539     {
 540       /* The type of a potentially-signed integer constant varies
 541          depending on the base it's in, the standard in use, and the
 542          length suffixes.  */
 543       enum integer_type_kind itk_u
 544         = narrowest_unsigned_type (integer.low, integer.high, flags);
 545       enum integer_type_kind itk_s
 546         = narrowest_signed_type (integer.low, integer.high, flags);
 547
 548       /* In both C89 and C99, octal and hex constants may be signed or
 549          unsigned, whichever fits tighter.  We do not warn about this
 550          choice differing from the traditional choice, as the constant
 551          is probably a bit pattern and either way will work.  */
 552       if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
 553         itk = MIN (itk_u, itk_s);
 554       else
 555         {
 556           /* In C99, decimal constants are always signed.
 557              In C89, decimal constants that don't fit in long have
 558              undefined behavior; we try to make them unsigned long.
 559              In GCC's extended C89, that last is true of decimal
 560              constants that don't fit in long long, too.  */
 561
 562           itk = itk_s;
 563           if (itk_s > itk_u && itk_s > itk_long)
 564             {
 565               if (!flag_isoc99)
 566                 {
 567                   if (itk_u < itk_unsigned_long)
 568                     itk_u = itk_unsigned_long;
 569                   itk = itk_u;
 570                   warning (0, "this decimal constant is unsigned only in ISO C90");
 571                 }
 572               else
 573                 warning (OPT_Wtraditional,
 574                          "this decimal constant would be unsigned in ISO C90");
 575             }
 576         }
 577     }
 578
 579   if (itk == itk_none)
 580     /* cpplib has already issued a warning for overflow.  */
 581     type = ((flags & CPP_N_UNSIGNED)
 582             ? widest_unsigned_literal_type_node
 583             : widest_integer_literal_type_node);
 584   else
 585     type = integer_types[itk];
 586
 587   if (itk > itk_unsigned_long
 588       && (flags & CPP_N_WIDTH) != CPP_N_LARGE
 589       && !in_system_header && !flag_isoc99)
 590     pedwarn (input_location, 0, "integer constant is too large for %qs type",
 591              (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
 592
 593   value = build_int_cst_wide (type, integer.low, integer.high);
 594
 595   /* Convert imaginary to a complex type.  */
 596   if (flags & CPP_N_IMAGINARY)
 597     value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
 598
 599   return value;
 600 }
 601
 602 /* Interpret TOKEN, a floating point number with FLAGS as classified
 603    by cpplib.  */
 604 static tree
 605 interpret_float (const cpp_token *token, unsigned int flags)
 606 {
 607   tree type;
 608   tree value;
 609   REAL_VALUE_TYPE real;
 610   char *copy;
 611   size_t copylen;
 612
 613   /* Decode _Fract and _Accum.  */
 614   if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
 615     return interpret_fixed (token, flags);
 616
 617   /* Decode type based on width and properties. */
 618   if (flags & CPP_N_DFLOAT)
 619     if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 620       type = dfloat128_type_node;
 621     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 622       type = dfloat32_type_node;
 623     else
 624       type = dfloat64_type_node;
 625   else
 626     if (flags & CPP_N_WIDTH_MD)
 627       {
 628         char suffix;
 629         enum machine_mode mode;
 630
 631         if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
 632           suffix = 'w';
 633         else
 634           suffix = 'q';
 635
 636         mode = targetm.c.mode_for_suffix (suffix);
 637         if (mode == VOIDmode)
 638           {
 639             error ("unsupported non-standard suffix on floating constant");
 640             errorcount++;
 641
 642             return error_mark_node;
 643           }
 644         else
 645           pedwarn (input_location, OPT_pedantic, "non-standard suffix on floating constant");
 646
 647         type = c_common_type_for_mode (mode, 0);
 648         gcc_assert (type);
 649       }
 650     else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 651       type = long_double_type_node;
 652     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
 653              || flag_single_precision_constant)
 654       type = float_type_node;
 655     else
 656       type = double_type_node;
 657
 658   /* Copy the constant to a nul-terminated buffer.  If the constant
 659      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
 660      can't handle them.  */
 661   copylen = token->val.str.len;
 662   if (flags & CPP_N_DFLOAT)
 663     copylen -= 2;
 664   else
 665     {
 666       if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
 667         /* Must be an F or L or machine defined suffix.  */
 668         copylen--;
 669       if (flags & CPP_N_IMAGINARY)
 670         /* I or J suffix.  */
 671         copylen--;
 672     }
 673
 674   copy = (char *) alloca (copylen + 1);
 675   memcpy (copy, token->val.str.text, copylen);
 676   copy[copylen] = '\0';
 677
 678   real_from_string3 (&real, copy, TYPE_MODE (type));
 679
 680   /* Both C and C++ require a diagnostic for a floating constant
 681      outside the range of representable values of its type.  Since we
 682      have __builtin_inf* to produce an infinity, this is now a
 683      mandatory pedwarn if the target does not support infinities.  */
 684   if (REAL_VALUE_ISINF (real))
 685     {
 686       if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
 687         pedwarn (input_location, 0, "floating constant exceeds range of %qT", type);
 688       else
 689         warning (OPT_Woverflow, "floating constant exceeds range of %qT", type);
 690     }
 691   /* We also give a warning if the value underflows.  */
 692   else if (REAL_VALUES_EQUAL (real, dconst0))
 693     {
 694       REAL_VALUE_TYPE realvoidmode;
 695       int overflow = real_from_string (&realvoidmode, copy);
 696       if (overflow < 0 || !REAL_VALUES_EQUAL (realvoidmode, dconst0))
 697         warning (OPT_Woverflow, "floating constant truncated to zero");
 698     }
 699
 700   /* Create a node with determined type and value.  */
 701   value = build_real (type, real);
 702   if (flags & CPP_N_IMAGINARY)
 703     value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
 704
 705   return value;
 706 }
 707
 708 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
 709    by cpplib.  */
 710
 711 static tree
 712 interpret_fixed (const cpp_token *token, unsigned int flags)
 713 {
 714   tree type;
 715   tree value;
 716   FIXED_VALUE_TYPE fixed;
 717   char *copy;
 718   size_t copylen;
 719
 720   copylen = token->val.str.len;
 721
 722   if (flags & CPP_N_FRACT) /* _Fract.  */
 723     {
 724       if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract.  */
 725         {
 726           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 727             {
 728               type = unsigned_long_long_fract_type_node;
 729               copylen -= 4;
 730             }
 731           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 732             {
 733               type = unsigned_long_fract_type_node;
 734               copylen -= 3;
 735             }
 736           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 737             {
 738               type = unsigned_short_fract_type_node;
 739               copylen -= 3;
 740             }
 741           else
 742             {
 743               type = unsigned_fract_type_node;
 744               copylen -= 2;
 745             }
 746         }
 747       else /* Signed _Fract.  */
 748         {
 749           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 750             {
 751               type = long_long_fract_type_node;
 752               copylen -= 3;
 753             }
 754           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 755             {
 756               type = long_fract_type_node;
 757               copylen -= 2;
 758             }
 759           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 760             {
 761               type = short_fract_type_node;
 762               copylen -= 2;
 763             }
 764           else
 765             {
 766               type = fract_type_node;
 767               copylen --;
 768             }
 769           }
 770     }
 771   else /* _Accum.  */
 772     {
 773       if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum.  */
 774         {
 775           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 776             {
 777               type = unsigned_long_long_accum_type_node;
 778               copylen -= 4;
 779             }
 780           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 781             {
 782               type = unsigned_long_accum_type_node;
 783               copylen -= 3;
 784             }
 785           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 786             {
 787               type = unsigned_short_accum_type_node;
 788               copylen -= 3;
 789              }
 790           else
 791             {
 792               type = unsigned_accum_type_node;
 793               copylen -= 2;
 794             }
 795         }
 796       else /* Signed _Accum.  */
 797         {
 798           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 799             {
 800               type = long_long_accum_type_node;
 801               copylen -= 3;
 802             }
 803           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 804             {
 805               type = long_accum_type_node;
 806               copylen -= 2;
 807             }
 808           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 809             {
 810               type = short_accum_type_node;
 811               copylen -= 2;
 812             }
 813           else
 814             {
 815               type = accum_type_node;
 816               copylen --;
 817             }
 818         }
 819     }
 820
 821   copy = (char *) alloca (copylen + 1);
 822   memcpy (copy, token->val.str.text, copylen);
 823   copy[copylen] = '\0';
 824
 825   fixed_from_string (&fixed, copy, TYPE_MODE (type));
 826
 827   /* Create a node with determined type and value.  */
 828   value = build_fixed (type, fixed);
 829
 830   return value;
 831 }
 832
 833 /* Convert a series of STRING, WSTRING, STRING16 and/or STRING32 tokens
 834    into a tree, performing string constant concatenation.  TOK is the
 835    first of these.  VALP is the location to write the string into.
 836    OBJC_STRING indicates whether an '@' token preceded the incoming token.
 837    Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
 838    CPP_STRING32, CPP_STRING16, or CPP_OBJC_STRING).
 839
 840    This is unfortunately more work than it should be.  If any of the
 841    strings in the series has an L prefix, the result is a wide string
 842    (6.4.5p4).  Whether or not the result is a wide string affects the
 843    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
 844    sequences do not continue across the boundary between two strings in
 845    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
 846    cpp_interpret_string takes a vector of cpp_string structures, which
 847    we must arrange to provide.  */
 848
 849 static enum cpp_ttype
 850 lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
 851 {
 852   tree value;
 853   size_t concats = 0;
 854   struct obstack str_ob;
 855   cpp_string istr;
 856   enum cpp_ttype type = tok->type;
 857
 858   /* Try to avoid the overhead of creating and destroying an obstack
 859      for the common case of just one string.  */
 860   cpp_string str = tok->val.str;
 861   cpp_string *strs = &str;
 862
 863  retry:
 864   tok = cpp_get_token (parse_in);
 865   switch (tok->type)
 866     {
 867     case CPP_PADDING:
 868       goto retry;
 869     case CPP_ATSIGN:
 870       if (c_dialect_objc ())
 871         {
 872           objc_string = true;
 873           goto retry;
 874         }
 875       /* FALLTHROUGH */
 876
 877     default:
 878       break;
 879
 880     case CPP_WSTRING:
 881     case CPP_STRING16:
 882     case CPP_STRING32:
 883       if (type != tok->type)
 884         {
 885           if (type == CPP_STRING)
 886             type = tok->type;
 887           else
 888             error ("unsupported non-standard concatenation of string literals");
 889         }
 890
 891     case CPP_STRING:
 892       if (!concats)
 893         {
 894           gcc_obstack_init (&str_ob);
 895           obstack_grow (&str_ob, &str, sizeof (cpp_string));
 896         }
 897
 898       concats++;
 899       obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
 900       goto retry;
 901     }
 902
 903   /* We have read one more token than we want.  */
 904   _cpp_backup_tokens (parse_in, 1);
 905   if (concats)
 906     strs = XOBFINISH (&str_ob, cpp_string *);
 907
 908   if (concats && !objc_string && !in_system_header)
 909     warning (OPT_Wtraditional,
 910              "traditional C rejects string constant concatenation");
 911
 912   if ((translate
 913        ? cpp_interpret_string : cpp_interpret_string_notranslate)
 914       (parse_in, strs, concats + 1, &istr, type))
 915     {
 916       value = build_string (istr.len, (const char *) istr.text);
 917       free (CONST_CAST (unsigned char *, istr.text));
 918     }
 919   else
 920     {
 921       /* Callers cannot generally handle error_mark_node in this context,
 922          so return the empty string instead.  cpp_interpret_string has
 923          issued an error.  */
 924       switch (type)
 925         {
 926         default:
 927         case CPP_STRING:
 928           value = build_string (1, "");
 929           break;
 930         case CPP_STRING16:
 931           value = build_string (TYPE_PRECISION (char16_type_node)
 932                                 / TYPE_PRECISION (char_type_node),
 933                                 "\0");  /* char16_t is 16 bits */
 934           break;
 935         case CPP_STRING32:
 936           value = build_string (TYPE_PRECISION (char32_type_node)
 937                                 / TYPE_PRECISION (char_type_node),
 938                                 "\0\0\0");  /* char32_t is 32 bits */
 939           break;
 940         case CPP_WSTRING:
 941           value = build_string (TYPE_PRECISION (wchar_type_node)
 942                                 / TYPE_PRECISION (char_type_node),
 943                                 "\0\0\0");  /* widest supported wchar_t
 944                                                is 32 bits */
 945           break;
 946         }
 947     }
 948
 949   switch (type)
 950     {
 951     default:
 952     case CPP_STRING:
 953       TREE_TYPE (value) = char_array_type_node;
 954       break;
 955     case CPP_STRING16:
 956       TREE_TYPE (value) = char16_array_type_node;
 957       break;
 958     case CPP_STRING32:
 959       TREE_TYPE (value) = char32_array_type_node;
 960       break;
 961     case CPP_WSTRING:
 962       TREE_TYPE (value) = wchar_array_type_node;
 963     }
 964   *valp = fix_string_type (value);
 965
 966   if (concats)
 967     obstack_free (&str_ob, 0);
 968
 969   return objc_string ? CPP_OBJC_STRING : type;
 970 }
 971
 972 /* Converts a (possibly wide) character constant token into a tree.  */
 973 static tree
 974 lex_charconst (const cpp_token *token)
 975 {
 976   cppchar_t result;
 977   tree type, value;
 978   unsigned int chars_seen;
 979   int unsignedp = 0;
 980
 981   result = cpp_interpret_charconst (parse_in, token,
 982                                     &chars_seen, &unsignedp);
 983
 984   if (token->type == CPP_WCHAR)
 985     type = wchar_type_node;
 986   else if (token->type == CPP_CHAR32)
 987     type = char32_type_node;
 988   else if (token->type == CPP_CHAR16)
 989     type = char16_type_node;
 990   /* In C, a character constant has type 'int'.
 991      In C++ 'char', but multi-char charconsts have type 'int'.  */
 992   else if (!c_dialect_cxx () || chars_seen > 1)
 993     type = integer_type_node;
 994   else
 995     type = char_type_node;
 996
 997   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
 998      before possibly widening to HOST_WIDE_INT for build_int_cst.  */
 999   if (unsignedp || (cppchar_signed_t) result >= 0)
1000     value = build_int_cst_wide (type, result, 0);
1001   else
1002     value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
1003
1004   return value;
1005 }