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