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