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