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