1 /* C/ObjC/C++ command line option handling. 2 Copyright (C) 2002-2018 Free Software Foundation, Inc. 3 Contributed by Neil Booth. 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify it under 8 the terms of the GNU General Public License as published by the Free 9 Software Foundation; either version 3, or (at your option) any later 10 version. 11 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 #include "config.h" 22 #include "system.h" 23 #include "coretypes.h" 24 #include "tm.h" 25 #include "c-target.h" 26 #include "c-common.h" 27 #include "memmodel.h" 28 #include "tm_p.h" /* For C_COMMON_OVERRIDE_OPTIONS. */ 29 #include "diagnostic.h" 30 #include "c-pragma.h" 31 #include "flags.h" 32 #include "toplev.h" 33 #include "langhooks.h" 34 #include "tree-diagnostic.h" /* for virt_loc_aware_diagnostic_finalizer */ 35 #include "intl.h" 36 #include "cppdefault.h" 37 #include "incpath.h" 38 #include "debug.h" /* For debug_hooks. */ 39 #include "opts.h" 40 #include "plugin.h" /* For PLUGIN_INCLUDE_FILE event. */ 41 #include "mkdeps.h" 42 #include "dumpfile.h" 43 #include "file-prefix-map.h" /* add_*_prefix_map() */ 44 45 #ifndef DOLLARS_IN_IDENTIFIERS 46 # define DOLLARS_IN_IDENTIFIERS true 47 #endif 48 49 #ifndef TARGET_SYSTEM_ROOT 50 # define TARGET_SYSTEM_ROOT NULL 51 #endif 52 53 #ifndef TARGET_OPTF 54 #define TARGET_OPTF(ARG) 55 #endif 56 57 /* CPP's options. */ 58 cpp_options *cpp_opts; 59 60 /* Input filename. */ 61 static const char *this_input_filename; 62 63 /* Filename and stream for preprocessed output. */ 64 static const char *out_fname; 65 static FILE *out_stream; 66 67 /* Append dependencies to deps_file. */ 68 static bool deps_append; 69 70 /* If dependency switches (-MF etc.) have been given. */ 71 static bool deps_seen; 72 73 /* If -v seen. */ 74 static bool verbose; 75 76 /* Dependency output file. */ 77 static const char *deps_file; 78 79 /* The prefix given by -iprefix, if any. */ 80 static const char *iprefix; 81 82 /* The multilib directory given by -imultilib, if any. */ 83 static const char *imultilib; 84 85 /* The system root, if any. Overridden by -isysroot. */ 86 static const char *sysroot = TARGET_SYSTEM_ROOT; 87 88 /* Zero disables all standard directories for headers. */ 89 static bool std_inc = true; 90 91 /* Zero disables the C++-specific standard directories for headers. */ 92 static bool std_cxx_inc = true; 93 94 /* If the quote chain has been split by -I-. */ 95 static bool quote_chain_split; 96 97 /* Number of deferred options. */ 98 static size_t deferred_count; 99 100 /* Number of deferred options scanned for -include. */ 101 static size_t include_cursor; 102 103 /* Dump files/flags to use during parsing. */ 104 static FILE *original_dump_file = NULL; 105 static dump_flags_t original_dump_flags; 106 107 /* Whether any standard preincluded header has been preincluded. */ 108 static bool done_preinclude; 109 110 static void handle_OPT_d (const char *); 111 static void set_std_cxx98 (int); 112 static void set_std_cxx11 (int); 113 static void set_std_cxx14 (int); 114 static void set_std_cxx17 (int); 115 static void set_std_cxx2a (int); 116 static void set_std_c89 (int, int); 117 static void set_std_c99 (int); 118 static void set_std_c11 (int); 119 static void set_std_c17 (int); 120 static void check_deps_environment_vars (void); 121 static void handle_deferred_opts (void); 122 static void sanitize_cpp_opts (void); 123 static void add_prefixed_path (const char *, incpath_kind); 124 static void push_command_line_include (void); 125 static void cb_file_change (cpp_reader *, const line_map_ordinary *); 126 static void cb_dir_change (cpp_reader *, const char *); 127 static void c_finish_options (void); 128 129 #ifndef STDC_0_IN_SYSTEM_HEADERS 130 #define STDC_0_IN_SYSTEM_HEADERS 0 131 #endif 132 133 /* Holds switches parsed by c_common_handle_option (), but whose 134 handling is deferred to c_common_post_options (). */ 135 static void defer_opt (enum opt_code, const char *); 136 static struct deferred_opt 137 { 138 enum opt_code code; 139 const char *arg; 140 } *deferred_opts; 141 142 143 extern const unsigned int 144 c_family_lang_mask = (CL_C | CL_CXX | CL_ObjC | CL_ObjCXX); 145 146 /* Defer option CODE with argument ARG. */ 147 static void 148 defer_opt (enum opt_code code, const char *arg) 149 { 150 deferred_opts[deferred_count].code = code; 151 deferred_opts[deferred_count].arg = arg; 152 deferred_count++; 153 } 154 155 /* Return language mask for option parsing. */ 156 unsigned int 157 c_common_option_lang_mask (void) 158 { 159 static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX}; 160 161 return lang_flags[c_language]; 162 } 163 164 /* Diagnostic finalizer for C/C++/Objective-C/Objective-C++. */ 165 static void 166 c_diagnostic_finalizer (diagnostic_context *context, 167 diagnostic_info *diagnostic) 168 { 169 diagnostic_show_locus (context, diagnostic->richloc, diagnostic->kind); 170 /* By default print macro expansion contexts in the diagnostic 171 finalizer -- for tokens resulting from macro expansion. */ 172 virt_loc_aware_diagnostic_finalizer (context, diagnostic); 173 pp_destroy_prefix (context->printer); 174 pp_flush (context->printer); 175 } 176 177 /* Common default settings for diagnostics. */ 178 void 179 c_common_diagnostics_set_defaults (diagnostic_context *context) 180 { 181 diagnostic_finalizer (context) = c_diagnostic_finalizer; 182 context->opt_permissive = OPT_fpermissive; 183 } 184 185 /* Whether options from all C-family languages should be accepted 186 quietly. */ 187 static bool accept_all_c_family_options = false; 188 189 /* Return whether to complain about a wrong-language option. */ 190 bool 191 c_common_complain_wrong_lang_p (const struct cl_option *option) 192 { 193 if (accept_all_c_family_options 194 && (option->flags & c_family_lang_mask)) 195 return false; 196 197 return true; 198 } 199 200 /* Initialize options structure OPTS. */ 201 void 202 c_common_init_options_struct (struct gcc_options *opts) 203 { 204 opts->x_flag_exceptions = c_dialect_cxx (); 205 opts->x_warn_pointer_arith = c_dialect_cxx (); 206 opts->x_warn_write_strings = c_dialect_cxx (); 207 opts->x_flag_warn_unused_result = true; 208 209 /* By default, C99-like requirements for complex multiply and divide. */ 210 opts->x_flag_complex_method = 2; 211 } 212 213 /* Common initialization before calling option handlers. */ 214 void 215 c_common_init_options (unsigned int decoded_options_count, 216 struct cl_decoded_option *decoded_options) 217 { 218 unsigned int i; 219 struct cpp_callbacks *cb; 220 221 g_string_concat_db 222 = new (ggc_alloc <string_concat_db> ()) string_concat_db (); 223 224 parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89, 225 ident_hash, line_table); 226 cb = cpp_get_callbacks (parse_in); 227 cb->error = c_cpp_error; 228 229 cpp_opts = cpp_get_options (parse_in); 230 cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS; 231 cpp_opts->objc = c_dialect_objc (); 232 233 /* Reset to avoid warnings on internal definitions. We set it just 234 before passing on command-line options to cpplib. */ 235 cpp_opts->warn_dollars = 0; 236 237 deferred_opts = XNEWVEC (struct deferred_opt, decoded_options_count); 238 239 if (c_language == clk_c) 240 { 241 /* The default for C is gnu17. */ 242 set_std_c17 (false /* ISO */); 243 244 /* If preprocessing assembly language, accept any of the C-family 245 front end options since the driver may pass them through. */ 246 for (i = 1; i < decoded_options_count; i++) 247 if (decoded_options[i].opt_index == OPT_lang_asm) 248 { 249 accept_all_c_family_options = true; 250 break; 251 } 252 } 253 254 /* Set C++ standard to C++14 if not specified on the command line. */ 255 if (c_dialect_cxx ()) 256 set_std_cxx14 (/*ISO*/false); 257 258 global_dc->colorize_source_p = true; 259 } 260 261 /* Handle switch SCODE with argument ARG. VALUE is true, unless no- 262 form of an -f or -W option was given. Returns false if the switch was 263 invalid, true if valid. Use HANDLERS in recursive handle_option calls. */ 264 bool 265 c_common_handle_option (size_t scode, const char *arg, int value, 266 int kind, location_t loc, 267 const struct cl_option_handlers *handlers) 268 { 269 const struct cl_option *option = &cl_options[scode]; 270 enum opt_code code = (enum opt_code) scode; 271 bool result = true; 272 273 /* Prevent resetting the language standard to a C dialect when the driver 274 has already determined that we're looking at assembler input. */ 275 bool preprocessing_asm_p = (cpp_get_options (parse_in)->lang == CLK_ASM); 276 277 switch (code) 278 { 279 default: 280 if (cl_options[code].flags & c_family_lang_mask) 281 { 282 if ((option->flags & CL_TARGET) 283 && ! targetcm.handle_c_option (scode, arg, value)) 284 result = false; 285 break; 286 } 287 result = false; 288 break; 289 290 case OPT__output_pch_: 291 pch_file = arg; 292 break; 293 294 case OPT_A: 295 defer_opt (code, arg); 296 break; 297 298 case OPT_C: 299 cpp_opts->discard_comments = 0; 300 break; 301 302 case OPT_CC: 303 cpp_opts->discard_comments = 0; 304 cpp_opts->discard_comments_in_macro_exp = 0; 305 break; 306 307 case OPT_cxx_isystem: 308 add_path (xstrdup (arg), INC_SYSTEM, 1, true); 309 break; 310 311 case OPT_D: 312 defer_opt (code, arg); 313 break; 314 315 case OPT_H: 316 cpp_opts->print_include_names = 1; 317 break; 318 319 case OPT_F: 320 TARGET_OPTF (xstrdup (arg)); 321 break; 322 323 case OPT_I: 324 if (strcmp (arg, "-")) 325 add_path (xstrdup (arg), INC_BRACKET, 0, true); 326 else 327 { 328 if (quote_chain_split) 329 error ("-I- specified twice"); 330 quote_chain_split = true; 331 split_quote_chain (); 332 inform (input_location, "obsolete option -I- used, please use -iquote instead"); 333 } 334 break; 335 336 case OPT_M: 337 case OPT_MM: 338 /* When doing dependencies with -M or -MM, suppress normal 339 preprocessed output, but still do -dM etc. as software 340 depends on this. Preprocessed output does occur if -MD, -MMD 341 or environment var dependency generation is used. */ 342 cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER); 343 flag_no_output = 1; 344 break; 345 346 case OPT_MD: 347 case OPT_MMD: 348 cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER); 349 cpp_opts->deps.need_preprocessor_output = true; 350 deps_file = arg; 351 break; 352 353 case OPT_MF: 354 deps_seen = true; 355 deps_file = arg; 356 break; 357 358 case OPT_MG: 359 deps_seen = true; 360 cpp_opts->deps.missing_files = true; 361 break; 362 363 case OPT_MP: 364 deps_seen = true; 365 cpp_opts->deps.phony_targets = true; 366 break; 367 368 case OPT_MQ: 369 case OPT_MT: 370 deps_seen = true; 371 defer_opt (code, arg); 372 break; 373 374 case OPT_P: 375 flag_no_line_commands = 1; 376 break; 377 378 case OPT_U: 379 defer_opt (code, arg); 380 break; 381 382 case OPT_Wall: 383 /* ??? Don't add new options here. Use LangEnabledBy in c.opt. */ 384 385 cpp_opts->warn_num_sign_change = value; 386 break; 387 388 case OPT_Walloca_larger_than_: 389 if (!value) 390 inform (loc, "-Walloca-larger-than=0 is meaningless"); 391 break; 392 393 case OPT_Wvla_larger_than_: 394 if (!value) 395 inform (loc, "-Wvla-larger-than=0 is meaningless"); 396 break; 397 398 case OPT_Wunknown_pragmas: 399 /* Set to greater than 1, so that even unknown pragmas in 400 system headers will be warned about. */ 401 /* ??? There is no way to handle this automatically for now. */ 402 warn_unknown_pragmas = value * 2; 403 break; 404 405 case OPT_ansi: 406 if (!c_dialect_cxx ()) 407 set_std_c89 (false, true); 408 else 409 set_std_cxx98 (true); 410 break; 411 412 case OPT_d: 413 handle_OPT_d (arg); 414 break; 415 416 case OPT_Wabi_: 417 warn_abi = true; 418 if (value == 1) 419 { 420 warning (0, "%<-Wabi=1%> is not supported, using =2"); 421 value = 2; 422 } 423 warn_abi_version = value; 424 break; 425 426 case OPT_fcanonical_system_headers: 427 cpp_opts->canonical_system_headers = value; 428 break; 429 430 case OPT_fcond_mismatch: 431 if (!c_dialect_cxx ()) 432 { 433 flag_cond_mismatch = value; 434 break; 435 } 436 warning (0, "switch %qs is no longer supported", option->opt_text); 437 break; 438 439 case OPT_fbuiltin_: 440 if (value) 441 result = false; 442 else 443 disable_builtin_function (arg); 444 break; 445 446 case OPT_fdirectives_only: 447 cpp_opts->directives_only = value; 448 break; 449 450 case OPT_fdollars_in_identifiers: 451 cpp_opts->dollars_in_ident = value; 452 break; 453 454 case OPT_fmacro_prefix_map_: 455 add_macro_prefix_map (arg); 456 break; 457 458 case OPT_ffreestanding: 459 value = !value; 460 /* Fall through. */ 461 case OPT_fhosted: 462 flag_hosted = value; 463 flag_no_builtin = !value; 464 break; 465 466 case OPT_fconstant_string_class_: 467 constant_string_class_name = arg; 468 break; 469 470 case OPT_fextended_identifiers: 471 cpp_opts->extended_identifiers = value; 472 break; 473 474 case OPT_foperator_names: 475 cpp_opts->operator_names = value; 476 break; 477 478 case OPT_fpch_deps: 479 cpp_opts->restore_pch_deps = value; 480 break; 481 482 case OPT_fpch_preprocess: 483 flag_pch_preprocess = value; 484 break; 485 486 case OPT_fpermissive: 487 flag_permissive = value; 488 global_dc->permissive = value; 489 break; 490 491 case OPT_fpreprocessed: 492 cpp_opts->preprocessed = value; 493 break; 494 495 case OPT_fdebug_cpp: 496 cpp_opts->debug = 1; 497 break; 498 499 case OPT_ftrack_macro_expansion: 500 if (value) 501 value = 2; 502 /* Fall Through. */ 503 504 case OPT_ftrack_macro_expansion_: 505 if (arg && *arg != '\0') 506 cpp_opts->track_macro_expansion = value; 507 else 508 cpp_opts->track_macro_expansion = 2; 509 break; 510 511 case OPT_frepo: 512 flag_use_repository = value; 513 if (value) 514 flag_implicit_templates = 0; 515 break; 516 517 case OPT_ftabstop_: 518 /* It is documented that we silently ignore silly values. */ 519 if (value >= 1 && value <= 100) 520 cpp_opts->tabstop = value; 521 break; 522 523 case OPT_fexec_charset_: 524 cpp_opts->narrow_charset = arg; 525 break; 526 527 case OPT_fwide_exec_charset_: 528 cpp_opts->wide_charset = arg; 529 break; 530 531 case OPT_finput_charset_: 532 cpp_opts->input_charset = arg; 533 break; 534 535 case OPT_ftemplate_depth_: 536 max_tinst_depth = value; 537 break; 538 539 case OPT_fvisibility_inlines_hidden: 540 visibility_options.inlines_hidden = value; 541 break; 542 543 case OPT_femit_struct_debug_baseonly: 544 set_struct_debug_option (&global_options, loc, "base"); 545 break; 546 547 case OPT_femit_struct_debug_reduced: 548 set_struct_debug_option (&global_options, loc, 549 "dir:ord:sys,dir:gen:any,ind:base"); 550 break; 551 552 case OPT_femit_struct_debug_detailed_: 553 set_struct_debug_option (&global_options, loc, arg); 554 break; 555 556 case OPT_fext_numeric_literals: 557 cpp_opts->ext_numeric_literals = value; 558 break; 559 560 case OPT_idirafter: 561 add_path (xstrdup (arg), INC_AFTER, 0, true); 562 break; 563 564 case OPT_imacros: 565 case OPT_include: 566 defer_opt (code, arg); 567 break; 568 569 case OPT_imultilib: 570 imultilib = arg; 571 break; 572 573 case OPT_iprefix: 574 iprefix = arg; 575 break; 576 577 case OPT_iquote: 578 add_path (xstrdup (arg), INC_QUOTE, 0, true); 579 break; 580 581 case OPT_iremap: 582 add_cpp_remap_path (arg); 583 break; 584 585 case OPT_isysroot: 586 sysroot = arg; 587 break; 588 589 case OPT_isystem: 590 add_path (xstrdup (arg), INC_SYSTEM, 0, true); 591 break; 592 593 case OPT_iwithprefix: 594 add_prefixed_path (arg, INC_SYSTEM); 595 break; 596 597 case OPT_iwithprefixbefore: 598 add_prefixed_path (arg, INC_BRACKET); 599 break; 600 601 case OPT_lang_asm: 602 cpp_set_lang (parse_in, CLK_ASM); 603 cpp_opts->dollars_in_ident = false; 604 break; 605 606 case OPT_nostdinc: 607 std_inc = false; 608 break; 609 610 case OPT_nostdinc__: 611 std_cxx_inc = false; 612 break; 613 614 case OPT_o: 615 if (!out_fname) 616 out_fname = arg; 617 else 618 error ("output filename specified twice"); 619 break; 620 621 case OPT_print_objc_runtime_info: 622 print_struct_values = 1; 623 break; 624 625 case OPT_remap: 626 cpp_opts->remap = 1; 627 break; 628 629 case OPT_std_c__98: 630 case OPT_std_gnu__98: 631 if (!preprocessing_asm_p) 632 set_std_cxx98 (code == OPT_std_c__98 /* ISO */); 633 break; 634 635 case OPT_std_c__11: 636 case OPT_std_gnu__11: 637 if (!preprocessing_asm_p) 638 set_std_cxx11 (code == OPT_std_c__11 /* ISO */); 639 break; 640 641 case OPT_std_c__14: 642 case OPT_std_gnu__14: 643 if (!preprocessing_asm_p) 644 set_std_cxx14 (code == OPT_std_c__14 /* ISO */); 645 break; 646 647 case OPT_std_c__17: 648 case OPT_std_gnu__17: 649 if (!preprocessing_asm_p) 650 set_std_cxx17 (code == OPT_std_c__17 /* ISO */); 651 break; 652 653 case OPT_std_c__2a: 654 case OPT_std_gnu__2a: 655 if (!preprocessing_asm_p) 656 set_std_cxx2a (code == OPT_std_c__2a /* ISO */); 657 break; 658 659 case OPT_std_c90: 660 case OPT_std_iso9899_199409: 661 if (!preprocessing_asm_p) 662 set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */); 663 break; 664 665 case OPT_std_gnu90: 666 if (!preprocessing_asm_p) 667 set_std_c89 (false /* c94 */, false /* ISO */); 668 break; 669 670 case OPT_std_c99: 671 if (!preprocessing_asm_p) 672 set_std_c99 (true /* ISO */); 673 break; 674 675 case OPT_std_gnu99: 676 if (!preprocessing_asm_p) 677 set_std_c99 (false /* ISO */); 678 break; 679 680 case OPT_std_c11: 681 if (!preprocessing_asm_p) 682 set_std_c11 (true /* ISO */); 683 break; 684 685 case OPT_std_gnu11: 686 if (!preprocessing_asm_p) 687 set_std_c11 (false /* ISO */); 688 break; 689 690 case OPT_std_c17: 691 if (!preprocessing_asm_p) 692 set_std_c17 (true /* ISO */); 693 break; 694 695 case OPT_std_gnu17: 696 if (!preprocessing_asm_p) 697 set_std_c17 (false /* ISO */); 698 break; 699 700 case OPT_trigraphs: 701 cpp_opts->trigraphs = 1; 702 break; 703 704 case OPT_traditional_cpp: 705 cpp_opts->traditional = 1; 706 break; 707 708 case OPT_v: 709 verbose = true; 710 break; 711 } 712 713 switch (c_language) 714 { 715 case clk_c: 716 C_handle_option_auto (&global_options, &global_options_set, 717 scode, arg, value, 718 c_family_lang_mask, kind, 719 loc, handlers, global_dc); 720 break; 721 722 case clk_objc: 723 ObjC_handle_option_auto (&global_options, &global_options_set, 724 scode, arg, value, 725 c_family_lang_mask, kind, 726 loc, handlers, global_dc); 727 break; 728 729 case clk_cxx: 730 CXX_handle_option_auto (&global_options, &global_options_set, 731 scode, arg, value, 732 c_family_lang_mask, kind, 733 loc, handlers, global_dc); 734 break; 735 736 case clk_objcxx: 737 ObjCXX_handle_option_auto (&global_options, &global_options_set, 738 scode, arg, value, 739 c_family_lang_mask, kind, 740 loc, handlers, global_dc); 741 break; 742 743 default: 744 gcc_unreachable (); 745 } 746 747 cpp_handle_option_auto (&global_options, scode, cpp_opts); 748 return result; 749 } 750 751 /* Default implementation of TARGET_HANDLE_C_OPTION. */ 752 753 bool 754 default_handle_c_option (size_t code ATTRIBUTE_UNUSED, 755 const char *arg ATTRIBUTE_UNUSED, 756 int value ATTRIBUTE_UNUSED) 757 { 758 return false; 759 } 760 761 /* Post-switch processing. */ 762 bool 763 c_common_post_options (const char **pfilename) 764 { 765 struct cpp_callbacks *cb; 766 767 /* Canonicalize the input and output filenames. */ 768 if (in_fnames == NULL) 769 { 770 in_fnames = XNEWVEC (const char *, 1); 771 in_fnames[0] = ""; 772 } 773 else if (strcmp (in_fnames[0], "-") == 0) 774 { 775 if (pch_file) 776 error ("cannot use %<-%> as input filename for a precompiled header"); 777 778 in_fnames[0] = ""; 779 } 780 781 if (out_fname == NULL || !strcmp (out_fname, "-")) 782 out_fname = ""; 783 784 if (cpp_opts->deps.style == DEPS_NONE) 785 check_deps_environment_vars (); 786 787 handle_deferred_opts (); 788 789 sanitize_cpp_opts (); 790 791 register_include_chains (parse_in, sysroot, iprefix, imultilib, 792 std_inc, std_cxx_inc && c_dialect_cxx (), verbose); 793 794 #ifdef C_COMMON_OVERRIDE_OPTIONS 795 /* Some machines may reject certain combinations of C 796 language-specific options. */ 797 C_COMMON_OVERRIDE_OPTIONS; 798 #endif 799 800 /* Excess precision other than "fast" requires front-end 801 support. */ 802 if (c_dialect_cxx ()) 803 { 804 if (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD) 805 sorry ("-fexcess-precision=standard for C++"); 806 flag_excess_precision_cmdline = EXCESS_PRECISION_FAST; 807 } 808 else if (flag_excess_precision_cmdline == EXCESS_PRECISION_DEFAULT) 809 flag_excess_precision_cmdline = (flag_iso 810 ? EXCESS_PRECISION_STANDARD 811 : EXCESS_PRECISION_FAST); 812 813 /* ISO C restricts floating-point expression contraction to within 814 source-language expressions (-ffp-contract=on, currently an alias 815 for -ffp-contract=off). */ 816 if (flag_iso 817 && !c_dialect_cxx () 818 && (global_options_set.x_flag_fp_contract_mode 819 == (enum fp_contract_mode) 0) 820 && flag_unsafe_math_optimizations == 0) 821 flag_fp_contract_mode = FP_CONTRACT_OFF; 822 823 /* If we are compiling C, and we are outside of a standards mode, 824 we can permit the new values from ISO/IEC TS 18661-3 for 825 FLT_EVAL_METHOD. Otherwise, we must restrict the possible values to 826 the set specified in ISO C99/C11. */ 827 if (!flag_iso 828 && !c_dialect_cxx () 829 && (global_options_set.x_flag_permitted_flt_eval_methods 830 == PERMITTED_FLT_EVAL_METHODS_DEFAULT)) 831 flag_permitted_flt_eval_methods = PERMITTED_FLT_EVAL_METHODS_TS_18661; 832 else 833 flag_permitted_flt_eval_methods = PERMITTED_FLT_EVAL_METHODS_C11; 834 835 /* By default we use C99 inline semantics in GNU99 or C99 mode. C99 836 inline semantics are not supported in GNU89 or C89 mode. */ 837 if (flag_gnu89_inline == -1) 838 flag_gnu89_inline = !flag_isoc99; 839 else if (!flag_gnu89_inline && !flag_isoc99) 840 error ("-fno-gnu89-inline is only supported in GNU99 or C99 mode"); 841 842 /* Default to ObjC sjlj exception handling if NeXT runtime. */ 843 if (flag_objc_sjlj_exceptions < 0) 844 flag_objc_sjlj_exceptions = flag_next_runtime; 845 if (flag_objc_exceptions && !flag_objc_sjlj_exceptions) 846 flag_exceptions = 1; 847 848 /* If -ffreestanding, -fno-hosted or -fno-builtin then disable 849 pattern recognition. */ 850 if (!global_options_set.x_flag_tree_loop_distribute_patterns 851 && flag_no_builtin) 852 flag_tree_loop_distribute_patterns = 0; 853 854 /* -Woverlength-strings is off by default, but is enabled by -Wpedantic. 855 It is never enabled in C++, as the minimum limit is not normative 856 in that standard. */ 857 if (c_dialect_cxx ()) 858 warn_overlength_strings = 0; 859 860 /* Wmain is enabled by default in C++ but not in C. */ 861 /* Wmain is disabled by default for -ffreestanding (!flag_hosted), 862 even if -Wall or -Wpedantic was given (warn_main will be 2 if set 863 by -Wall, 1 if set by -Wmain). */ 864 if (warn_main == -1) 865 warn_main = (c_dialect_cxx () && flag_hosted) ? 1 : 0; 866 else if (warn_main == 2) 867 warn_main = flag_hosted ? 1 : 0; 868 869 /* In C, -Wall and -Wc++-compat enable -Wenum-compare; if it has not 870 yet been set, it is disabled by default. In C++, it is enabled 871 by default. */ 872 if (warn_enum_compare == -1) 873 warn_enum_compare = c_dialect_cxx () ? 1 : 0; 874 875 /* -Wpacked-bitfield-compat is on by default for the C languages. The 876 warning is issued in stor-layout.c which is not part of the front-end so 877 we need to selectively turn it on here. */ 878 if (warn_packed_bitfield_compat == -1) 879 warn_packed_bitfield_compat = 1; 880 881 /* Special format checking options don't work without -Wformat; warn if 882 they are used. */ 883 if (!warn_format) 884 { 885 warning (OPT_Wformat_y2k, 886 "-Wformat-y2k ignored without -Wformat"); 887 warning (OPT_Wformat_extra_args, 888 "-Wformat-extra-args ignored without -Wformat"); 889 warning (OPT_Wformat_zero_length, 890 "-Wformat-zero-length ignored without -Wformat"); 891 warning (OPT_Wformat_nonliteral, 892 "-Wformat-nonliteral ignored without -Wformat"); 893 warning (OPT_Wformat_contains_nul, 894 "-Wformat-contains-nul ignored without -Wformat"); 895 warning (OPT_Wformat_security, 896 "-Wformat-security ignored without -Wformat"); 897 } 898 899 /* -Wimplicit-function-declaration is enabled by default for C99. */ 900 if (warn_implicit_function_declaration == -1) 901 warn_implicit_function_declaration = flag_isoc99; 902 903 /* -Wimplicit-int is enabled by default for C99. */ 904 if (warn_implicit_int == -1) 905 warn_implicit_int = flag_isoc99; 906 907 /* -Wshift-overflow is enabled by default in C99 and C++11 modes. */ 908 if (warn_shift_overflow == -1) 909 warn_shift_overflow = cxx_dialect >= cxx11 || flag_isoc99; 910 911 /* -Wshift-negative-value is enabled by -Wextra in C99 and C++11 modes. */ 912 if (warn_shift_negative_value == -1) 913 warn_shift_negative_value = (extra_warnings 914 && (cxx_dialect >= cxx11 || flag_isoc99)); 915 916 /* -Wregister is enabled by default in C++17. */ 917 if (!global_options_set.x_warn_register) 918 warn_register = cxx_dialect >= cxx17; 919 920 /* Declone C++ 'structors if -Os. */ 921 if (flag_declone_ctor_dtor == -1) 922 flag_declone_ctor_dtor = optimize_size; 923 924 if (flag_abi_compat_version == 1) 925 { 926 warning (0, "%<-fabi-compat-version=1%> is not supported, using =2"); 927 flag_abi_compat_version = 2; 928 } 929 930 /* Change flag_abi_version to be the actual current ABI level, for the 931 benefit of c_cpp_builtins, and to make comparison simpler. */ 932 const int latest_abi_version = 13; 933 /* Generate compatibility aliases for ABI v11 (7.1) by default. */ 934 const int abi_compat_default = 11; 935 936 #define clamp(X) if (X == 0 || X > latest_abi_version) X = latest_abi_version 937 clamp (flag_abi_version); 938 clamp (warn_abi_version); 939 clamp (flag_abi_compat_version); 940 #undef clamp 941 942 /* Default -Wabi= or -fabi-compat-version= from each other. */ 943 if (warn_abi_version == -1 && flag_abi_compat_version != -1) 944 warn_abi_version = flag_abi_compat_version; 945 else if (flag_abi_compat_version == -1 && warn_abi_version != -1) 946 flag_abi_compat_version = warn_abi_version; 947 else if (warn_abi_version == -1 && flag_abi_compat_version == -1) 948 { 949 warn_abi_version = latest_abi_version; 950 if (flag_abi_version == latest_abi_version) 951 { 952 if (warning (OPT_Wabi, "-Wabi won't warn about anything")) 953 { 954 inform (input_location, "-Wabi warns about differences " 955 "from the most up-to-date ABI, which is also used " 956 "by default"); 957 inform (input_location, "use e.g. -Wabi=11 to warn about " 958 "changes from GCC 7"); 959 } 960 flag_abi_compat_version = abi_compat_default; 961 } 962 else 963 flag_abi_compat_version = latest_abi_version; 964 } 965 966 /* By default, enable the new inheriting constructor semantics along with ABI 967 11. New and old should coexist fine, but it is a change in what 968 artificial symbols are generated. */ 969 if (!global_options_set.x_flag_new_inheriting_ctors) 970 flag_new_inheriting_ctors = abi_version_at_least (11); 971 972 /* For GCC 7, only enable DR150 resolution by default if -std=c++17. */ 973 if (!global_options_set.x_flag_new_ttp) 974 flag_new_ttp = (cxx_dialect >= cxx17); 975 976 if (cxx_dialect >= cxx11) 977 { 978 /* If we're allowing C++0x constructs, don't warn about C++98 979 identifiers which are keywords in C++0x. */ 980 warn_cxx11_compat = 0; 981 cpp_opts->cpp_warn_cxx11_compat = 0; 982 983 if (warn_narrowing == -1) 984 warn_narrowing = 1; 985 986 /* Unless -f{,no-}ext-numeric-literals has been used explicitly, 987 for -std=c++{11,14,17,2a} default to -fno-ext-numeric-literals. */ 988 if (flag_iso && !global_options_set.x_flag_ext_numeric_literals) 989 cpp_opts->ext_numeric_literals = 0; 990 } 991 else if (warn_narrowing == -1) 992 warn_narrowing = 0; 993 994 /* C++17 has stricter evaluation order requirements; let's use some of them 995 for earlier C++ as well, so chaining works as expected. */ 996 if (c_dialect_cxx () 997 && flag_strong_eval_order == -1) 998 flag_strong_eval_order = (cxx_dialect >= cxx17 ? 2 : 1); 999 1000 /* Global sized deallocation is new in C++14. */ 1001 if (flag_sized_deallocation == -1) 1002 flag_sized_deallocation = (cxx_dialect >= cxx14); 1003 1004 if (flag_extern_tls_init) 1005 { 1006 if (!TARGET_SUPPORTS_ALIASES || !SUPPORTS_WEAK) 1007 { 1008 /* Lazy TLS initialization for a variable in another TU requires 1009 alias and weak reference support. */ 1010 if (flag_extern_tls_init > 0) 1011 sorry ("external TLS initialization functions not supported " 1012 "on this target"); 1013 1014 flag_extern_tls_init = 0; 1015 } 1016 else 1017 flag_extern_tls_init = 1; 1018 } 1019 1020 if (warn_return_type == -1) 1021 warn_return_type = c_dialect_cxx (); 1022 1023 if (num_in_fnames > 1) 1024 error ("too many filenames given. Type %s --help for usage", 1025 progname); 1026 1027 if (flag_preprocess_only) 1028 { 1029 /* Open the output now. We must do so even if flag_no_output is 1030 on, because there may be other output than from the actual 1031 preprocessing (e.g. from -dM). */ 1032 if (out_fname[0] == '\0') 1033 out_stream = stdout; 1034 else 1035 out_stream = fopen (out_fname, "w"); 1036 1037 if (out_stream == NULL) 1038 { 1039 fatal_error (input_location, "opening output file %s: %m", out_fname); 1040 return false; 1041 } 1042 1043 init_pp_output (out_stream); 1044 } 1045 else 1046 { 1047 init_c_lex (); 1048 1049 /* When writing a PCH file, avoid reading some other PCH file, 1050 because the default address space slot then can't be used 1051 for the output PCH file. */ 1052 if (pch_file) 1053 { 1054 c_common_no_more_pch (); 1055 /* Only -g0 and -gdwarf* are supported with PCH, for other 1056 debug formats we warn here and refuse to load any PCH files. */ 1057 if (write_symbols != NO_DEBUG && write_symbols != DWARF2_DEBUG) 1058 warning (OPT_Wdeprecated, 1059 "the \"%s\" debug format cannot be used with " 1060 "pre-compiled headers", debug_type_names[write_symbols]); 1061 } 1062 else if (write_symbols != NO_DEBUG && write_symbols != DWARF2_DEBUG) 1063 c_common_no_more_pch (); 1064 1065 /* Yuk. WTF is this? I do know ObjC relies on it somewhere. */ 1066 input_location = UNKNOWN_LOCATION; 1067 } 1068 1069 cb = cpp_get_callbacks (parse_in); 1070 cb->file_change = cb_file_change; 1071 cb->dir_change = cb_dir_change; 1072 cpp_post_options (parse_in); 1073 init_global_opts_from_cpp (&global_options, cpp_get_options (parse_in)); 1074 1075 input_location = UNKNOWN_LOCATION; 1076 1077 *pfilename = this_input_filename 1078 = cpp_read_main_file (parse_in, in_fnames[0]); 1079 /* Don't do any compilation or preprocessing if there is no input file. */ 1080 if (this_input_filename == NULL) 1081 { 1082 errorcount++; 1083 return false; 1084 } 1085 1086 if (flag_working_directory 1087 && flag_preprocess_only && !flag_no_line_commands) 1088 pp_dir_change (parse_in, get_src_pwd ()); 1089 1090 /* Disable LTO output when outputting a precompiled header. */ 1091 if (pch_file && flag_lto) 1092 { 1093 flag_lto = 0; 1094 flag_generate_lto = 0; 1095 } 1096 1097 return flag_preprocess_only; 1098 } 1099 1100 /* Front end initialization common to C, ObjC and C++. */ 1101 bool 1102 c_common_init (void) 1103 { 1104 /* Set up preprocessor arithmetic. Must be done after call to 1105 c_common_nodes_and_builtins for type nodes to be good. */ 1106 cpp_opts->precision = TYPE_PRECISION (intmax_type_node); 1107 cpp_opts->char_precision = TYPE_PRECISION (char_type_node); 1108 cpp_opts->int_precision = TYPE_PRECISION (integer_type_node); 1109 cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node); 1110 cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node); 1111 cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN; 1112 1113 /* This can't happen until after wchar_precision and bytes_big_endian 1114 are known. */ 1115 cpp_init_iconv (parse_in); 1116 1117 if (version_flag) 1118 { 1119 int i; 1120 fputs ("Compiler executable checksum: ", stderr); 1121 for (i = 0; i < 16; i++) 1122 fprintf (stderr, "%02x", executable_checksum[i]); 1123 putc ('\n', stderr); 1124 } 1125 1126 /* Has to wait until now so that cpplib has its hash table. */ 1127 init_pragma (); 1128 1129 if (flag_preprocess_only) 1130 { 1131 c_finish_options (); 1132 preprocess_file (parse_in); 1133 return false; 1134 } 1135 1136 return true; 1137 } 1138 1139 /* Initialize the integrated preprocessor after debug output has been 1140 initialized; loop over each input file. */ 1141 void 1142 c_common_parse_file (void) 1143 { 1144 unsigned int i; 1145 1146 i = 0; 1147 for (;;) 1148 { 1149 c_finish_options (); 1150 /* Open the dump file to use for the original dump output 1151 here, to be used during parsing for the current file. */ 1152 original_dump_file = dump_begin (TDI_original, &original_dump_flags); 1153 pch_init (); 1154 push_file_scope (); 1155 c_parse_file (); 1156 pop_file_scope (); 1157 /* And end the main input file, if the debug writer wants it */ 1158 if (debug_hooks->start_end_main_source_file) 1159 (*debug_hooks->end_source_file) (0); 1160 if (++i >= num_in_fnames) 1161 break; 1162 cpp_undef_all (parse_in); 1163 cpp_clear_file_cache (parse_in); 1164 this_input_filename 1165 = cpp_read_main_file (parse_in, in_fnames[i]); 1166 if (original_dump_file) 1167 { 1168 dump_end (TDI_original, original_dump_file); 1169 original_dump_file = NULL; 1170 } 1171 /* If an input file is missing, abandon further compilation. 1172 cpplib has issued a diagnostic. */ 1173 if (!this_input_filename) 1174 break; 1175 } 1176 1177 c_parse_final_cleanups (); 1178 } 1179 1180 /* Returns the appropriate dump file for PHASE to dump with FLAGS. */ 1181 1182 FILE * 1183 get_dump_info (int phase, dump_flags_t *flags) 1184 { 1185 gcc_assert (phase == TDI_original); 1186 1187 *flags = original_dump_flags; 1188 return original_dump_file; 1189 } 1190 1191 /* Common finish hook for the C, ObjC and C++ front ends. */ 1192 void 1193 c_common_finish (void) 1194 { 1195 FILE *deps_stream = NULL; 1196 1197 /* Note that we write the dependencies even if there are errors. This is 1198 useful for handling outdated generated headers that now trigger errors 1199 (for example, with #error) which would be resolved by re-generating 1200 them. In a sense, this complements -MG. */ 1201 if (cpp_opts->deps.style != DEPS_NONE) 1202 { 1203 /* If -M or -MM was seen without -MF, default output to the 1204 output stream. */ 1205 if (!deps_file) 1206 deps_stream = out_stream; 1207 else if (deps_file[0] == '-' && deps_file[1] == '\0') 1208 deps_stream = stdout; 1209 else 1210 { 1211 deps_stream = fopen (deps_file, deps_append ? "a": "w"); 1212 if (!deps_stream) 1213 fatal_error (input_location, "opening dependency file %s: %m", 1214 deps_file); 1215 } 1216 } 1217 1218 /* For performance, avoid tearing down cpplib's internal structures 1219 with cpp_destroy (). */ 1220 cpp_finish (parse_in, deps_stream); 1221 1222 if (deps_stream && deps_stream != out_stream && deps_stream != stdout 1223 && (ferror (deps_stream) || fclose (deps_stream))) 1224 fatal_error (input_location, "closing dependency file %s: %m", deps_file); 1225 1226 if (out_stream && (ferror (out_stream) || fclose (out_stream))) 1227 fatal_error (input_location, "when writing output to %s: %m", out_fname); 1228 } 1229 1230 /* Either of two environment variables can specify output of 1231 dependencies. Their value is either "OUTPUT_FILE" or "OUTPUT_FILE 1232 DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to 1233 and DEPS_TARGET is the target to mention in the deps. They also 1234 result in dependency information being appended to the output file 1235 rather than overwriting it, and like Sun's compiler 1236 SUNPRO_DEPENDENCIES suppresses the dependency on the main file. */ 1237 static void 1238 check_deps_environment_vars (void) 1239 { 1240 char *spec; 1241 1242 spec = getenv ("DEPENDENCIES_OUTPUT"); 1243 if (spec) 1244 cpp_opts->deps.style = DEPS_USER; 1245 else 1246 { 1247 spec = getenv ("SUNPRO_DEPENDENCIES"); 1248 if (spec) 1249 { 1250 cpp_opts->deps.style = DEPS_SYSTEM; 1251 cpp_opts->deps.ignore_main_file = true; 1252 } 1253 } 1254 1255 if (spec) 1256 { 1257 /* Find the space before the DEPS_TARGET, if there is one. */ 1258 char *s = strchr (spec, ' '); 1259 if (s) 1260 { 1261 /* Let the caller perform MAKE quoting. */ 1262 defer_opt (OPT_MT, s + 1); 1263 *s = '\0'; 1264 } 1265 1266 /* Command line -MF overrides environment variables and default. */ 1267 if (!deps_file) 1268 deps_file = spec; 1269 1270 deps_append = 1; 1271 deps_seen = true; 1272 } 1273 } 1274 1275 /* Handle deferred command line switches. */ 1276 static void 1277 handle_deferred_opts (void) 1278 { 1279 size_t i; 1280 struct deps *deps; 1281 1282 /* Avoid allocating the deps buffer if we don't need it. 1283 (This flag may be true without there having been -MT or -MQ 1284 options, but we'll still need the deps buffer.) */ 1285 if (!deps_seen) 1286 return; 1287 1288 deps = cpp_get_deps (parse_in); 1289 1290 for (i = 0; i < deferred_count; i++) 1291 { 1292 struct deferred_opt *opt = &deferred_opts[i]; 1293 1294 if (opt->code == OPT_MT || opt->code == OPT_MQ) 1295 deps_add_target (deps, opt->arg, opt->code == OPT_MQ); 1296 } 1297 } 1298 1299 /* These settings are appropriate for GCC, but not necessarily so for 1300 cpplib as a library. */ 1301 static void 1302 sanitize_cpp_opts (void) 1303 { 1304 /* If we don't know what style of dependencies to output, complain 1305 if any other dependency switches have been given. */ 1306 if (deps_seen && cpp_opts->deps.style == DEPS_NONE) 1307 error ("to generate dependencies you must specify either -M or -MM"); 1308 1309 /* -dM and dependencies suppress normal output; do it here so that 1310 the last -d[MDN] switch overrides earlier ones. */ 1311 if (flag_dump_macros == 'M') 1312 flag_no_output = 1; 1313 1314 /* By default, -fdirectives-only implies -dD. This allows subsequent phases 1315 to perform proper macro expansion. */ 1316 if (cpp_opts->directives_only && !cpp_opts->preprocessed && !flag_dump_macros) 1317 flag_dump_macros = 'D'; 1318 1319 /* Disable -dD, -dN and -dI if normal output is suppressed. Allow 1320 -dM since at least glibc relies on -M -dM to work. */ 1321 /* Also, flag_no_output implies flag_no_line_commands, always. */ 1322 if (flag_no_output) 1323 { 1324 if (flag_dump_macros != 'M') 1325 flag_dump_macros = 0; 1326 flag_dump_includes = 0; 1327 flag_no_line_commands = 1; 1328 } 1329 else if (cpp_opts->deps.missing_files) 1330 error ("-MG may only be used with -M or -MM"); 1331 1332 cpp_opts->unsigned_char = !flag_signed_char; 1333 cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS; 1334 1335 /* Wlong-long is disabled by default. It is enabled by: 1336 [-Wpedantic | -Wtraditional] -std=[gnu|c]++98 ; or 1337 [-Wpedantic | -Wtraditional] -std=non-c99 1338 1339 Either -Wlong-long or -Wno-long-long override any other settings. 1340 ??? These conditions should be handled in c.opt. */ 1341 if (warn_long_long == -1) 1342 { 1343 warn_long_long = ((pedantic || warn_traditional) 1344 && (c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99)); 1345 cpp_opts->cpp_warn_long_long = warn_long_long; 1346 } 1347 1348 /* If we're generating preprocessor output, emit current directory 1349 if explicitly requested or if debugging information is enabled. 1350 ??? Maybe we should only do it for debugging formats that 1351 actually output the current directory? */ 1352 if (flag_working_directory == -1) 1353 flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE); 1354 1355 if (warn_implicit_fallthrough < 5) 1356 cpp_opts->cpp_warn_implicit_fallthrough = warn_implicit_fallthrough; 1357 else 1358 cpp_opts->cpp_warn_implicit_fallthrough = 0; 1359 1360 if (cpp_opts->directives_only) 1361 { 1362 if (cpp_warn_unused_macros) 1363 error ("-fdirectives-only is incompatible with -Wunused_macros"); 1364 if (cpp_opts->traditional) 1365 error ("-fdirectives-only is incompatible with -traditional"); 1366 } 1367 } 1368 1369 /* Add include path with a prefix at the front of its name. */ 1370 static void 1371 add_prefixed_path (const char *suffix, incpath_kind chain) 1372 { 1373 char *path; 1374 const char *prefix; 1375 size_t prefix_len, suffix_len; 1376 1377 suffix_len = strlen (suffix); 1378 prefix = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR; 1379 prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len; 1380 1381 path = (char *) xmalloc (prefix_len + suffix_len + 1); 1382 memcpy (path, prefix, prefix_len); 1383 memcpy (path + prefix_len, suffix, suffix_len); 1384 path[prefix_len + suffix_len] = '\0'; 1385 1386 add_path (path, chain, 0, false); 1387 } 1388 1389 /* Handle -D, -U, -A, -imacros, and the first -include. */ 1390 static void 1391 c_finish_options (void) 1392 { 1393 if (!cpp_opts->preprocessed) 1394 { 1395 size_t i; 1396 1397 cb_file_change (parse_in, 1398 linemap_check_ordinary (linemap_add (line_table, 1399 LC_RENAME, 0, 1400 _("<built-in>"), 1401 0))); 1402 /* Make sure all of the builtins about to be declared have 1403 BUILTINS_LOCATION has their source_location. */ 1404 source_location builtins_loc = BUILTINS_LOCATION; 1405 cpp_force_token_locations (parse_in, &builtins_loc); 1406 1407 cpp_init_builtins (parse_in, flag_hosted); 1408 c_cpp_builtins (parse_in); 1409 1410 cpp_stop_forcing_token_locations (parse_in); 1411 1412 /* We're about to send user input to cpplib, so make it warn for 1413 things that we previously (when we sent it internal definitions) 1414 told it to not warn. 1415 1416 C99 permits implementation-defined characters in identifiers. 1417 The documented meaning of -std= is to turn off extensions that 1418 conflict with the specified standard, and since a strictly 1419 conforming program cannot contain a '$', we do not condition 1420 their acceptance on the -std= setting. */ 1421 cpp_opts->warn_dollars = (cpp_opts->cpp_pedantic && !cpp_opts->c99); 1422 1423 cb_file_change (parse_in, 1424 linemap_check_ordinary (linemap_add (line_table, LC_RENAME, 0, 1425 _("<command-line>"), 0))); 1426 1427 for (i = 0; i < deferred_count; i++) 1428 { 1429 struct deferred_opt *opt = &deferred_opts[i]; 1430 1431 if (opt->code == OPT_D) 1432 cpp_define (parse_in, opt->arg); 1433 else if (opt->code == OPT_U) 1434 cpp_undef (parse_in, opt->arg); 1435 else if (opt->code == OPT_A) 1436 { 1437 if (opt->arg[0] == '-') 1438 cpp_unassert (parse_in, opt->arg + 1); 1439 else 1440 cpp_assert (parse_in, opt->arg); 1441 } 1442 } 1443 1444 /* Start the main input file, if the debug writer wants it. */ 1445 if (debug_hooks->start_end_main_source_file 1446 && !flag_preprocess_only) 1447 (*debug_hooks->start_source_file) (0, this_input_filename); 1448 1449 /* Handle -imacros after -D and -U. */ 1450 for (i = 0; i < deferred_count; i++) 1451 { 1452 struct deferred_opt *opt = &deferred_opts[i]; 1453 1454 if (opt->code == OPT_imacros 1455 && cpp_push_include (parse_in, opt->arg)) 1456 { 1457 /* Disable push_command_line_include callback for now. */ 1458 include_cursor = deferred_count + 1; 1459 cpp_scan_nooutput (parse_in); 1460 } 1461 } 1462 } 1463 else 1464 { 1465 if (cpp_opts->directives_only) 1466 cpp_init_special_builtins (parse_in); 1467 1468 /* Start the main input file, if the debug writer wants it. */ 1469 if (debug_hooks->start_end_main_source_file 1470 && !flag_preprocess_only) 1471 (*debug_hooks->start_source_file) (0, this_input_filename); 1472 } 1473 1474 include_cursor = 0; 1475 push_command_line_include (); 1476 } 1477 1478 /* Give CPP the next file given by -include, if any. */ 1479 static void 1480 push_command_line_include (void) 1481 { 1482 /* This can happen if disabled by -imacros for example. 1483 Punt so that we don't set "<command-line>" as the filename for 1484 the header. */ 1485 if (include_cursor > deferred_count) 1486 return; 1487 1488 if (!done_preinclude) 1489 { 1490 done_preinclude = true; 1491 if (flag_hosted && std_inc && !cpp_opts->preprocessed) 1492 { 1493 const char *preinc = targetcm.c_preinclude (); 1494 if (preinc && cpp_push_default_include (parse_in, preinc)) 1495 return; 1496 } 1497 } 1498 1499 pch_cpp_save_state (); 1500 1501 while (include_cursor < deferred_count) 1502 { 1503 struct deferred_opt *opt = &deferred_opts[include_cursor++]; 1504 1505 if (!cpp_opts->preprocessed && opt->code == OPT_include 1506 && cpp_push_include (parse_in, opt->arg)) 1507 return; 1508 } 1509 1510 if (include_cursor == deferred_count) 1511 { 1512 include_cursor++; 1513 /* -Wunused-macros should only warn about macros defined hereafter. */ 1514 cpp_opts->warn_unused_macros = cpp_warn_unused_macros; 1515 /* Restore the line map from <command line>. */ 1516 if (!cpp_opts->preprocessed) 1517 cpp_change_file (parse_in, LC_RENAME, this_input_filename); 1518 1519 /* Set this here so the client can change the option if it wishes, 1520 and after stacking the main file so we don't trace the main file. */ 1521 line_table->trace_includes = cpp_opts->print_include_names; 1522 } 1523 } 1524 1525 /* File change callback. Has to handle -include files. */ 1526 static void 1527 cb_file_change (cpp_reader * ARG_UNUSED (pfile), 1528 const line_map_ordinary *new_map) 1529 { 1530 if (flag_preprocess_only) 1531 pp_file_change (new_map); 1532 else 1533 fe_file_change (new_map); 1534 1535 if (new_map 1536 && (new_map->reason == LC_ENTER || new_map->reason == LC_RENAME)) 1537 { 1538 /* Signal to plugins that a file is included. This could happen 1539 several times with the same file path, e.g. because of 1540 several '#include' or '#line' directives... */ 1541 invoke_plugin_callbacks 1542 (PLUGIN_INCLUDE_FILE, 1543 const_cast<char*> (ORDINARY_MAP_FILE_NAME (new_map))); 1544 } 1545 1546 if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map))) 1547 { 1548 pch_cpp_save_state (); 1549 push_command_line_include (); 1550 } 1551 } 1552 1553 void 1554 cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir) 1555 { 1556 if (!set_src_pwd (dir)) 1557 warning (0, "too late for # directive to set debug directory"); 1558 } 1559 1560 /* Set the C 89 standard (with 1994 amendments if C94, without GNU 1561 extensions if ISO). There is no concept of gnu94. */ 1562 static void 1563 set_std_c89 (int c94, int iso) 1564 { 1565 cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89); 1566 flag_iso = iso; 1567 flag_no_asm = iso; 1568 flag_no_gnu_keywords = iso; 1569 flag_no_nonansi_builtin = iso; 1570 flag_isoc94 = c94; 1571 flag_isoc99 = 0; 1572 flag_isoc11 = 0; 1573 lang_hooks.name = "GNU C89"; 1574 } 1575 1576 /* Set the C 99 standard (without GNU extensions if ISO). */ 1577 static void 1578 set_std_c99 (int iso) 1579 { 1580 cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99); 1581 flag_no_asm = iso; 1582 flag_no_nonansi_builtin = iso; 1583 flag_iso = iso; 1584 flag_isoc11 = 0; 1585 flag_isoc99 = 1; 1586 flag_isoc94 = 1; 1587 lang_hooks.name = "GNU C99"; 1588 } 1589 1590 /* Set the C 11 standard (without GNU extensions if ISO). */ 1591 static void 1592 set_std_c11 (int iso) 1593 { 1594 cpp_set_lang (parse_in, iso ? CLK_STDC11: CLK_GNUC11); 1595 flag_no_asm = iso; 1596 flag_no_nonansi_builtin = iso; 1597 flag_iso = iso; 1598 flag_isoc11 = 1; 1599 flag_isoc99 = 1; 1600 flag_isoc94 = 1; 1601 lang_hooks.name = "GNU C11"; 1602 } 1603 1604 /* Set the C 17 standard (without GNU extensions if ISO). */ 1605 static void 1606 set_std_c17 (int iso) 1607 { 1608 cpp_set_lang (parse_in, iso ? CLK_STDC17: CLK_GNUC17); 1609 flag_no_asm = iso; 1610 flag_no_nonansi_builtin = iso; 1611 flag_iso = iso; 1612 flag_isoc11 = 1; 1613 flag_isoc99 = 1; 1614 flag_isoc94 = 1; 1615 lang_hooks.name = "GNU C17"; 1616 } 1617 1618 1619 /* Set the C++ 98 standard (without GNU extensions if ISO). */ 1620 static void 1621 set_std_cxx98 (int iso) 1622 { 1623 cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX); 1624 flag_no_gnu_keywords = iso; 1625 flag_no_nonansi_builtin = iso; 1626 flag_iso = iso; 1627 flag_isoc94 = 0; 1628 flag_isoc99 = 0; 1629 cxx_dialect = cxx98; 1630 lang_hooks.name = "GNU C++98"; 1631 } 1632 1633 /* Set the C++ 2011 standard (without GNU extensions if ISO). */ 1634 static void 1635 set_std_cxx11 (int iso) 1636 { 1637 cpp_set_lang (parse_in, iso ? CLK_CXX11: CLK_GNUCXX11); 1638 flag_no_gnu_keywords = iso; 1639 flag_no_nonansi_builtin = iso; 1640 flag_iso = iso; 1641 /* C++11 includes the C99 standard library. */ 1642 flag_isoc94 = 1; 1643 flag_isoc99 = 1; 1644 cxx_dialect = cxx11; 1645 lang_hooks.name = "GNU C++11"; 1646 } 1647 1648 /* Set the C++ 2014 standard (without GNU extensions if ISO). */ 1649 static void 1650 set_std_cxx14 (int iso) 1651 { 1652 cpp_set_lang (parse_in, iso ? CLK_CXX14: CLK_GNUCXX14); 1653 flag_no_gnu_keywords = iso; 1654 flag_no_nonansi_builtin = iso; 1655 flag_iso = iso; 1656 /* C++14 includes the C99 standard library. */ 1657 flag_isoc94 = 1; 1658 flag_isoc99 = 1; 1659 cxx_dialect = cxx14; 1660 lang_hooks.name = "GNU C++14"; 1661 } 1662 1663 /* Set the C++ 2017 standard (without GNU extensions if ISO). */ 1664 static void 1665 set_std_cxx17 (int iso) 1666 { 1667 cpp_set_lang (parse_in, iso ? CLK_CXX17: CLK_GNUCXX17); 1668 flag_no_gnu_keywords = iso; 1669 flag_no_nonansi_builtin = iso; 1670 flag_iso = iso; 1671 /* C++17 includes the C11 standard library. */ 1672 flag_isoc94 = 1; 1673 flag_isoc99 = 1; 1674 flag_isoc11 = 1; 1675 cxx_dialect = cxx17; 1676 lang_hooks.name = "GNU C++17"; 1677 } 1678 1679 /* Set the C++ 202a draft standard (without GNU extensions if ISO). */ 1680 static void 1681 set_std_cxx2a (int iso) 1682 { 1683 cpp_set_lang (parse_in, iso ? CLK_CXX2A: CLK_GNUCXX2A); 1684 flag_no_gnu_keywords = iso; 1685 flag_no_nonansi_builtin = iso; 1686 flag_iso = iso; 1687 /* C++17 includes the C11 standard library. */ 1688 flag_isoc94 = 1; 1689 flag_isoc99 = 1; 1690 flag_isoc11 = 1; 1691 cxx_dialect = cxx2a; 1692 lang_hooks.name = "GNU C++17"; /* Pretend C++17 until standardization. */ 1693 } 1694 1695 /* Args to -d specify what to dump. Silently ignore 1696 unrecognized options; they may be aimed at toplev.c. */ 1697 static void 1698 handle_OPT_d (const char *arg) 1699 { 1700 char c; 1701 1702 while ((c = *arg++) != '\0') 1703 switch (c) 1704 { 1705 case 'M': /* Dump macros only. */ 1706 case 'N': /* Dump names. */ 1707 case 'D': /* Dump definitions. */ 1708 case 'U': /* Dump used macros. */ 1709 flag_dump_macros = c; 1710 break; 1711 1712 case 'I': 1713 flag_dump_includes = 1; 1714 break; 1715 } 1716 } 1717