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