1/* C/ObjC/C++ command line option handling. 2 Copyright (C) 2002, 2003, 2004, 2005, 2006 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 2, 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 COPYING. If not, write to the Free 19Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2002110-1301, USA. */ 21 22#include "config.h" 23#include "system.h" 24#include "coretypes.h" 25#include "tm.h" 26#include "tree.h" 27#include "c-common.h" 28#include "c-pragma.h" 29#include "flags.h" 30#include "toplev.h" 31#include "langhooks.h" 32#include "tree-inline.h" 33#include "diagnostic.h" 34#include "intl.h" 35#include "cppdefault.h" 36#include "c-incpath.h" 37#include "debug.h" /* For debug_hooks. */ 38#include "opts.h" 39#include "options.h" 40#include "mkdeps.h" 41 42#ifndef DOLLARS_IN_IDENTIFIERS 43# define DOLLARS_IN_IDENTIFIERS true 44#endif 45 46#ifndef TARGET_SYSTEM_ROOT 47# define TARGET_SYSTEM_ROOT NULL 48#endif 49 50#ifndef TARGET_OPTF 51#define TARGET_OPTF(ARG) 52#endif 53 54/* CPP's options. */ 55static cpp_options *cpp_opts; 56 57/* Input filename. */ 58static const char *this_input_filename; 59 60/* Filename and stream for preprocessed output. */ 61static const char *out_fname; 62static FILE *out_stream; 63 64/* Append dependencies to deps_file. */ 65static bool deps_append; 66 67/* If dependency switches (-MF etc.) have been given. */ 68static bool deps_seen; 69 70/* If -v seen. */ 71static bool verbose; 72 73/* If -lang-fortran seen. */ 74static bool lang_fortran = false; 75 76/* Dependency output file. */ 77static const char *deps_file; 78 79/* The prefix given by -iprefix, if any. */ 80static const char *iprefix; 81 82/* The system root, if any. Overridden by -isysroot. */ 83static const char *sysroot = TARGET_SYSTEM_ROOT; 84 85/* Zero disables all standard directories for headers. */ 86static bool std_inc = true; 87 88/* Zero disables the C++-specific standard directories for headers. */ 89static bool std_cxx_inc = true; 90 91/* If the quote chain has been split by -I-. */ 92static bool quote_chain_split; 93 94/* If -Wunused-macros. */ 95static bool warn_unused_macros; 96 97/* If -Wvariadic-macros. */ 98static bool warn_variadic_macros = true; 99 100/* Number of deferred options. */ 101static size_t deferred_count; 102 103/* Number of deferred options scanned for -include. */ 104static size_t include_cursor; 105 106static void set_Wimplicit (int); 107static void handle_OPT_d (const char *); 108static void set_std_cxx98 (int); 109static void set_std_c89 (int, int); 110static void set_std_c99 (int); 111static void check_deps_environment_vars (void); 112static void handle_deferred_opts (void); 113static void sanitize_cpp_opts (void); 114static void add_prefixed_path (const char *, size_t); 115static void push_command_line_include (void); 116static void cb_file_change (cpp_reader *, const struct line_map *); 117static void cb_dir_change (cpp_reader *, const char *); 118static void finish_options (void); 119 120#ifndef STDC_0_IN_SYSTEM_HEADERS 121#define STDC_0_IN_SYSTEM_HEADERS 0 122#endif 123 124/* Holds switches parsed by c_common_handle_option (), but whose 125 handling is deferred to c_common_post_options (). */ 126static void defer_opt (enum opt_code, const char *); 127static struct deferred_opt 128{ 129 enum opt_code code; 130 const char *arg; 131} *deferred_opts; 132 133/* Complain that switch CODE expects an argument but none was 134 provided. OPT was the command-line option. Return FALSE to get 135 the default message in opts.c, TRUE if we provide a specialized 136 one. */ 137bool 138c_common_missing_argument (const char *opt, size_t code) 139{ 140 switch (code) 141 { 142 default: 143 /* Pick up the default message. */ 144 return false; 145 146 case OPT_fconstant_string_class_: 147 error ("no class name specified with %qs", opt); 148 break; 149 150 case OPT_A: 151 error ("assertion missing after %qs", opt); 152 break; 153 154 case OPT_D: 155 case OPT_U: 156 error ("macro name missing after %qs", opt); 157 break; 158 159 case OPT_cxx_isystem: 160 case OPT_F: 161 case OPT_I: 162 case OPT_idirafter: 163 case OPT_isysroot: 164 case OPT_isystem: 165 case OPT_iquote: 166 case OPT_iremap: 167 error ("missing path after %qs", opt); 168 break; 169 170 case OPT_MF: 171 case OPT_MD: 172 case OPT_MMD: 173 case OPT_include: 174 case OPT_imacros: 175 case OPT_o: 176 error ("missing filename after %qs", opt); 177 break; 178 179 case OPT_MQ: 180 case OPT_MT: 181 error ("missing makefile target after %qs", opt); 182 break; 183 } 184 185 return true; 186} 187 188/* Defer option CODE with argument ARG. */ 189static void 190defer_opt (enum opt_code code, const char *arg) 191{ 192 deferred_opts[deferred_count].code = code; 193 deferred_opts[deferred_count].arg = arg; 194 deferred_count++; 195} 196 197/* Common initialization before parsing options. */ 198unsigned int 199c_common_init_options (unsigned int argc, const char **argv) 200{ 201 static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX}; 202 unsigned int i, result; 203 204 /* This is conditionalized only because that is the way the front 205 ends used to do it. Maybe this should be unconditional? */ 206 if (c_dialect_cxx ()) 207 { 208 /* By default wrap lines at 80 characters. Is getenv 209 ("COLUMNS") preferable? */ 210 diagnostic_line_cutoff (global_dc) = 80; 211 /* By default, emit location information once for every 212 diagnostic message. */ 213 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE; 214 } 215 216 parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89, 217 ident_hash, &line_table); 218 219 cpp_opts = cpp_get_options (parse_in); 220 cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS; 221 cpp_opts->objc = c_dialect_objc (); 222 223 /* Reset to avoid warnings on internal definitions. We set it just 224 before passing on command-line options to cpplib. */ 225 cpp_opts->warn_dollars = 0; 226 227 flag_const_strings = c_dialect_cxx (); 228 flag_exceptions = c_dialect_cxx (); 229 warn_pointer_arith = c_dialect_cxx (); 230 231 deferred_opts = XNEWVEC (struct deferred_opt, argc); 232 233 result = lang_flags[c_language]; 234 235 if (c_language == clk_c) 236 { 237 /* If preprocessing assembly language, accept any of the C-family 238 front end options since the driver may pass them through. */ 239 for (i = 1; i < argc; i++) 240 if (! strcmp (argv[i], "-lang-asm")) 241 { 242 result |= CL_C | CL_ObjC | CL_CXX | CL_ObjCXX; 243 break; 244 } 245 246#ifdef CL_Fortran 247 for (i = 1; i < argc; i++) 248 if (! strcmp (argv[i], "-lang-fortran")) 249 { 250 result |= CL_Fortran; 251 break; 252 } 253#endif 254 } 255 256 return result; 257} 258 259/* Handle switch SCODE with argument ARG. VALUE is true, unless no- 260 form of an -f or -W option was given. Returns 0 if the switch was 261 invalid, a negative number to prevent language-independent 262 processing in toplev.c (a hack necessary for the short-term). */ 263int 264c_common_handle_option (size_t scode, const char *arg, int value) 265{ 266 const struct cl_option *option = &cl_options[scode]; 267 enum opt_code code = (enum opt_code) scode; 268 int result = 1; 269 270 /* Prevent resetting the language standard to a C dialect when the driver 271 has already determined that we're looking at assembler input. */ 272 bool preprocessing_asm_p = (cpp_get_options (parse_in)->lang == CLK_ASM); 273 274 switch (code) 275 { 276 default: 277 if (cl_options[code].flags & (CL_C | CL_CXX | CL_ObjC | CL_ObjCXX)) 278 break; 279#ifdef CL_Fortran 280 if (lang_fortran && (cl_options[code].flags & (CL_Fortran))) 281 break; 282#endif 283 result = 0; 284 break; 285 286 case OPT__output_pch_: 287 pch_file = arg; 288 break; 289 290 case OPT_A: 291 defer_opt (code, arg); 292 break; 293 294 case OPT_C: 295 cpp_opts->discard_comments = 0; 296 break; 297 298 case OPT_CC: 299 cpp_opts->discard_comments = 0; 300 cpp_opts->discard_comments_in_macro_exp = 0; 301 break; 302 303 case OPT_D: 304 defer_opt (code, arg); 305 break; 306 307 case OPT_E: 308 flag_preprocess_only = 1; 309 break; 310 311 case OPT_H: 312 cpp_opts->print_include_names = 1; 313 break; 314 315 case OPT_F: 316 TARGET_OPTF (xstrdup (arg)); 317 break; 318 319 case OPT_I: 320 if (strcmp (arg, "-")) 321 add_path (xstrdup (arg), BRACKET, 0, true); 322 else 323 { 324 if (quote_chain_split) 325 error ("-I- specified twice"); 326 quote_chain_split = true; 327 split_quote_chain (); 328 inform ("obsolete option -I- used, please use -iquote instead"); 329 } 330 break; 331 332 case OPT_M: 333 case OPT_MM: 334 /* When doing dependencies with -M or -MM, suppress normal 335 preprocessed output, but still do -dM etc. as software 336 depends on this. Preprocessed output does occur if -MD, -MMD 337 or environment var dependency generation is used. */ 338 cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER); 339 flag_no_output = 1; 340 cpp_opts->inhibit_warnings = 1; 341 break; 342 343 case OPT_MD: 344 case OPT_MMD: 345 cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER); 346 deps_file = arg; 347 break; 348 349 case OPT_MF: 350 deps_seen = true; 351 deps_file = arg; 352 break; 353 354 case OPT_MG: 355 deps_seen = true; 356 cpp_opts->deps.missing_files = true; 357 break; 358 359 case OPT_MP: 360 deps_seen = true; 361 cpp_opts->deps.phony_targets = true; 362 break; 363 364 case OPT_MQ: 365 case OPT_MT: 366 deps_seen = true; 367 defer_opt (code, arg); 368 break; 369 370 case OPT_P: 371 flag_no_line_commands = 1; 372 break; 373 374 case OPT_fworking_directory: 375 flag_working_directory = value; 376 break; 377 378 case OPT_U: 379 defer_opt (code, arg); 380 break; 381 382 case OPT_Wall: 383 set_Wunused (value); 384 set_Wformat (value); 385 set_Wimplicit (value); 386 warn_char_subscripts = value; 387 warn_missing_braces = value; 388 warn_parentheses = value; 389 warn_return_type = value; 390 warn_sequence_point = value; /* Was C only. */ 391 if (c_dialect_cxx ()) 392 warn_sign_compare = value; 393 warn_switch = value; 394 warn_strict_aliasing = value; 395 396 /* Only warn about unknown pragmas that are not in system 397 headers. */ 398 warn_unknown_pragmas = value; 399 400 /* We save the value of warn_uninitialized, since if they put 401 -Wuninitialized on the command line, we need to generate a 402 warning about not using it without also specifying -O. */ 403 if (warn_uninitialized != 1) 404 warn_uninitialized = (value ? 2 : 0); 405 406 if (!c_dialect_cxx ()) 407 /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding 408 can turn it off only if it's not explicit. */ 409 warn_main = value * 2; 410 else 411 { 412 /* C++-specific warnings. */ 413 warn_nonvdtor = value; 414 warn_reorder = value; 415 warn_nontemplate_friend = value; 416 } 417 418 cpp_opts->warn_trigraphs = value; 419 cpp_opts->warn_comments = value; 420 cpp_opts->warn_num_sign_change = value; 421 cpp_opts->warn_multichar = value; /* Was C++ only. */ 422 423 if (warn_pointer_sign == -1) 424 warn_pointer_sign = 1; 425 break; 426 427 case OPT_Wcomment: 428 case OPT_Wcomments: 429 cpp_opts->warn_comments = value; 430 break; 431 432 case OPT_Wdeprecated: 433 cpp_opts->warn_deprecated = value; 434 break; 435 436 case OPT_Wdiv_by_zero: 437 warn_div_by_zero = value; 438 break; 439 440 case OPT_Wendif_labels: 441 cpp_opts->warn_endif_labels = value; 442 break; 443 444 case OPT_Werror: 445 cpp_opts->warnings_are_errors = value; 446 global_dc->warning_as_error_requested = value; 447 break; 448 449 case OPT_Werror_implicit_function_declaration: 450 mesg_implicit_function_declaration = 2; 451 break; 452 453 case OPT_Wformat: 454 set_Wformat (value); 455 break; 456 457 case OPT_Wformat_: 458 set_Wformat (atoi (arg)); 459 break; 460 461 case OPT_Wimplicit: 462 set_Wimplicit (value); 463 break; 464 465 case OPT_Wimport: 466 /* Silently ignore for now. */ 467 break; 468 469 case OPT_Winvalid_pch: 470 cpp_opts->warn_invalid_pch = value; 471 break; 472 473 case OPT_Wmain: 474 if (value) 475 warn_main = 1; 476 else 477 warn_main = -1; 478 break; 479 480 case OPT_Wmissing_include_dirs: 481 cpp_opts->warn_missing_include_dirs = value; 482 break; 483 484 case OPT_Wmultichar: 485 cpp_opts->warn_multichar = value; 486 break; 487 488 case OPT_Wnormalized_: 489 if (!value || (arg && strcasecmp (arg, "none") == 0)) 490 cpp_opts->warn_normalize = normalized_none; 491 else if (!arg || strcasecmp (arg, "nfkc") == 0) 492 cpp_opts->warn_normalize = normalized_KC; 493 else if (strcasecmp (arg, "id") == 0) 494 cpp_opts->warn_normalize = normalized_identifier_C; 495 else if (strcasecmp (arg, "nfc") == 0) 496 cpp_opts->warn_normalize = normalized_C; 497 else 498 error ("argument %qs to %<-Wnormalized%> not recognized", arg); 499 break; 500 501 case OPT_Wreturn_type: 502 warn_return_type = value; 503 break; 504 505 case OPT_Wstrict_null_sentinel: 506 warn_strict_null_sentinel = value; 507 break; 508 509 case OPT_Wsystem_headers: 510 cpp_opts->warn_system_headers = value; 511 break; 512 513 case OPT_Wtraditional: 514 cpp_opts->warn_traditional = value; 515 break; 516 517 case OPT_Wtrigraphs: 518 cpp_opts->warn_trigraphs = value; 519 break; 520 521 case OPT_Wundef: 522 cpp_opts->warn_undef = value; 523 break; 524 525 case OPT_Wunknown_pragmas: 526 /* Set to greater than 1, so that even unknown pragmas in 527 system headers will be warned about. */ 528 warn_unknown_pragmas = value * 2; 529 break; 530 531 case OPT_Wunused_macros: 532 warn_unused_macros = value; 533 break; 534 535 case OPT_Wvariadic_macros: 536 warn_variadic_macros = value; 537 break; 538 539 case OPT_Wwrite_strings: 540 if (!c_dialect_cxx ()) 541 flag_const_strings = value; 542 else 543 warn_write_strings = value; 544 break; 545 546 case OPT_ansi: 547 if (!c_dialect_cxx ()) 548 set_std_c89 (false, true); 549 else 550 set_std_cxx98 (true); 551 break; 552 553 case OPT_cxx_isystem: 554 add_path (xstrdup (arg), SYSTEM, 1, true); 555 break; 556 557 case OPT_d: 558 handle_OPT_d (arg); 559 break; 560 561 case OPT_fcond_mismatch: 562 if (!c_dialect_cxx ()) 563 { 564 flag_cond_mismatch = value; 565 break; 566 } 567 /* Fall through. */ 568 569 case OPT_fall_virtual: 570 case OPT_falt_external_templates: 571 case OPT_fenum_int_equiv: 572 case OPT_fexternal_templates: 573 case OPT_fguiding_decls: 574 case OPT_fhonor_std: 575 case OPT_fhuge_objects: 576 case OPT_flabels_ok: 577 case OPT_fname_mangling_version_: 578 case OPT_fnew_abi: 579 case OPT_fnonnull_objects: 580 case OPT_fsquangle: 581 case OPT_fstrict_prototype: 582 case OPT_fthis_is_variable: 583 case OPT_fvtable_thunks: 584 case OPT_fxref: 585 case OPT_fvtable_gc: 586 warning (0, "switch %qs is no longer supported", option->opt_text); 587 break; 588 589 case OPT_faccess_control: 590 flag_access_control = value; 591 break; 592 593 case OPT_fasm: 594 flag_no_asm = !value; 595 break; 596 597 case OPT_fbuiltin: 598 flag_no_builtin = !value; 599 break; 600 601 case OPT_fbuiltin_: 602 if (value) 603 result = 0; 604 else 605 disable_builtin_function (arg); 606 break; 607 608 case OPT_fdollars_in_identifiers: 609 cpp_opts->dollars_in_ident = value; 610 break; 611 612 case OPT_ffreestanding: 613 value = !value; 614 /* Fall through.... */ 615 case OPT_fhosted: 616 flag_hosted = value; 617 flag_no_builtin = !value; 618 /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */ 619 if (!value && warn_main == 2) 620 warn_main = 0; 621 break; 622 623 case OPT_fshort_double: 624 flag_short_double = value; 625 break; 626 627 case OPT_fshort_enums: 628 flag_short_enums = value; 629 break; 630 631 case OPT_fshort_wchar: 632 flag_short_wchar = value; 633 break; 634 635 case OPT_fsigned_bitfields: 636 flag_signed_bitfields = value; 637 break; 638 639 case OPT_fsigned_char: 640 flag_signed_char = value; 641 break; 642 643 case OPT_funsigned_bitfields: 644 flag_signed_bitfields = !value; 645 break; 646 647 case OPT_funsigned_char: 648 flag_signed_char = !value; 649 break; 650 651 case OPT_fcheck_new: 652 flag_check_new = value; 653 break; 654 655 case OPT_fconserve_space: 656 flag_conserve_space = value; 657 break; 658 659 case OPT_fconst_strings: 660 flag_const_strings = value; 661 break; 662 663 case OPT_fconstant_string_class_: 664 constant_string_class_name = arg; 665 break; 666 667 case OPT_fdefault_inline: 668 flag_default_inline = value; 669 break; 670 671 case OPT_felide_constructors: 672 flag_elide_constructors = value; 673 break; 674 675 case OPT_fenforce_eh_specs: 676 flag_enforce_eh_specs = value; 677 break; 678 679 case OPT_fextended_identifiers: 680 cpp_opts->extended_identifiers = value; 681 break; 682 683 case OPT_ffor_scope: 684 flag_new_for_scope = value; 685 break; 686 687 case OPT_fgnu_keywords: 688 flag_no_gnu_keywords = !value; 689 break; 690 691 case OPT_fgnu_runtime: 692 flag_next_runtime = !value; 693 break; 694 695 case OPT_fhandle_exceptions: 696 warning (0, "-fhandle-exceptions has been renamed -fexceptions (and is now on by default)"); 697 flag_exceptions = value; 698 break; 699 700 case OPT_fimplement_inlines: 701 flag_implement_inlines = value; 702 break; 703 704 case OPT_fimplicit_inline_templates: 705 flag_implicit_inline_templates = value; 706 break; 707 708 case OPT_fimplicit_templates: 709 flag_implicit_templates = value; 710 break; 711 712 case OPT_fms_extensions: 713 flag_ms_extensions = value; 714 break; 715 716 case OPT_fnext_runtime: 717 flag_next_runtime = value; 718 break; 719 720 case OPT_fnil_receivers: 721 flag_nil_receivers = value; 722 break; 723 724 case OPT_fnonansi_builtins: 725 flag_no_nonansi_builtin = !value; 726 break; 727 728 case OPT_foperator_names: 729 cpp_opts->operator_names = value; 730 break; 731 732 case OPT_foptional_diags: 733 flag_optional_diags = value; 734 break; 735 736 case OPT_fpch_deps: 737 cpp_opts->restore_pch_deps = value; 738 break; 739 740 case OPT_fpch_preprocess: 741 flag_pch_preprocess = value; 742 break; 743 744 case OPT_fpermissive: 745 flag_permissive = value; 746 break; 747 748 case OPT_fpreprocessed: 749 cpp_opts->preprocessed = value; 750 break; 751 752 case OPT_freplace_objc_classes: 753 flag_replace_objc_classes = value; 754 break; 755 756 case OPT_frepo: 757 flag_use_repository = value; 758 if (value) 759 flag_implicit_templates = 0; 760 break; 761 762 case OPT_frtti: 763 flag_rtti = value; 764 break; 765 766 case OPT_fshow_column: 767 cpp_opts->show_column = value; 768 break; 769 770 case OPT_fstats: 771 flag_detailed_statistics = value; 772 break; 773 774 case OPT_ftabstop_: 775 /* It is documented that we silently ignore silly values. */ 776 if (value >= 1 && value <= 100) 777 cpp_opts->tabstop = value; 778 break; 779 780 case OPT_fexec_charset_: 781 cpp_opts->narrow_charset = arg; 782 break; 783 784 case OPT_fwide_exec_charset_: 785 cpp_opts->wide_charset = arg; 786 break; 787 788 case OPT_finput_charset_: 789 cpp_opts->input_charset = arg; 790 break; 791 792 case OPT_ftemplate_depth_: 793 max_tinst_depth = value; 794 break; 795 796 case OPT_fuse_cxa_atexit: 797 flag_use_cxa_atexit = value; 798 break; 799 800 case OPT_fvisibility_inlines_hidden: 801 visibility_options.inlines_hidden = value; 802 break; 803 804 case OPT_fweak: 805 flag_weak = value; 806 break; 807 808 case OPT_fthreadsafe_statics: 809 flag_threadsafe_statics = value; 810 break; 811 812 case OPT_fzero_link: 813 flag_zero_link = value; 814 break; 815 816 case OPT_gen_decls: 817 flag_gen_declaration = 1; 818 break; 819 820 case OPT_idirafter: 821 add_path (xstrdup (arg), AFTER, 0, true); 822 break; 823 824 case OPT_imacros: 825 case OPT_include: 826 defer_opt (code, arg); 827 break; 828 829 case OPT_iprefix: 830 iprefix = arg; 831 break; 832 833 case OPT_iquote: 834 add_path (xstrdup (arg), QUOTE, 0, true); 835 break; 836 837 case OPT_isysroot: 838 sysroot = arg; 839 break; 840 841 case OPT_isystem: 842 add_path (xstrdup (arg), SYSTEM, 0, true); 843 break; 844 845 case OPT_iremap: 846 add_cpp_remap_path (arg); 847 break; 848 849 case OPT_iwithprefix: 850 add_prefixed_path (arg, SYSTEM); 851 break; 852 853 case OPT_iwithprefixbefore: 854 add_prefixed_path (arg, BRACKET); 855 break; 856 857 case OPT_lang_asm: 858 cpp_set_lang (parse_in, CLK_ASM); 859 cpp_opts->dollars_in_ident = false; 860 break; 861 862 case OPT_lang_fortran: 863 lang_fortran = true; 864 break; 865 866 case OPT_lang_objc: 867 cpp_opts->objc = 1; 868 break; 869 870 case OPT_nostdinc: 871 std_inc = false; 872 break; 873 874 case OPT_nostdinc__: 875 std_cxx_inc = false; 876 break; 877 878 case OPT_o: 879 if (!out_fname) 880 out_fname = arg; 881 else 882 error ("output filename specified twice"); 883 break; 884 885 /* We need to handle the -pedantic switches here, rather than in 886 c_common_post_options, so that a subsequent -Wno-endif-labels 887 is not overridden. */ 888 case OPT_pedantic_errors: 889 cpp_opts->pedantic_errors = 1; 890 /* Fall through. */ 891 case OPT_pedantic: 892 cpp_opts->pedantic = 1; 893 cpp_opts->warn_endif_labels = 1; 894 if (warn_pointer_sign == -1) 895 warn_pointer_sign = 1; 896 break; 897 898 case OPT_print_objc_runtime_info: 899 print_struct_values = 1; 900 break; 901 902 case OPT_print_pch_checksum: 903 c_common_print_pch_checksum (stdout); 904 exit_after_options = true; 905 break; 906 907 case OPT_remap: 908 cpp_opts->remap = 1; 909 break; 910 911 case OPT_std_c__98: 912 case OPT_std_gnu__98: 913 if (!preprocessing_asm_p) 914 set_std_cxx98 (code == OPT_std_c__98 /* ISO */); 915 break; 916 917 case OPT_std_c89: 918 case OPT_std_iso9899_1990: 919 case OPT_std_iso9899_199409: 920 if (!preprocessing_asm_p) 921 set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */); 922 break; 923 924 case OPT_std_gnu89: 925 if (!preprocessing_asm_p) 926 set_std_c89 (false /* c94 */, false /* ISO */); 927 break; 928 929 case OPT_std_c99: 930 case OPT_std_c9x: 931 case OPT_std_iso9899_1999: 932 case OPT_std_iso9899_199x: 933 if (!preprocessing_asm_p) 934 set_std_c99 (true /* ISO */); 935 break; 936 937 case OPT_std_gnu99: 938 case OPT_std_gnu9x: 939 if (!preprocessing_asm_p) 940 set_std_c99 (false /* ISO */); 941 break; 942 943 case OPT_trigraphs: 944 cpp_opts->trigraphs = 1; 945 break; 946 947 case OPT_traditional_cpp: 948 cpp_opts->traditional = 1; 949 break; 950 951 case OPT_undef: 952 flag_undef = 1; 953 break; 954 955 case OPT_w: 956 cpp_opts->inhibit_warnings = 1; 957 break; 958 959 case OPT_v: 960 verbose = true; 961 break; 962 } 963 964 return result; 965} 966 967/* Post-switch processing. */ 968bool 969c_common_post_options (const char **pfilename) 970{ 971 struct cpp_callbacks *cb; 972 973 /* Canonicalize the input and output filenames. */ 974 if (in_fnames == NULL) 975 { 976 in_fnames = XNEWVEC (const char *, 1); 977 in_fnames[0] = ""; 978 } 979 else if (strcmp (in_fnames[0], "-") == 0) 980 in_fnames[0] = ""; 981 982 if (out_fname == NULL || !strcmp (out_fname, "-")) 983 out_fname = ""; 984 985 if (cpp_opts->deps.style == DEPS_NONE) 986 check_deps_environment_vars (); 987 988 handle_deferred_opts (); 989 990 sanitize_cpp_opts (); 991 992 register_include_chains (parse_in, sysroot, iprefix, 993 std_inc, std_cxx_inc && c_dialect_cxx (), verbose); 994 995 flag_inline_trees = 1; 996 997 /* Use tree inlining. */ 998 if (!flag_no_inline) 999 flag_no_inline = 1; 1000 if (flag_inline_functions) 1001 flag_inline_trees = 2; 1002 1003 /* We recognize -fgnu89-inline in preparation for 4.3 where the 1004 option will be meaningful. Here we just reject 1005 -fno-gnu89-inline, since we don't support it. */ 1006 if (!flag_gnu89_inline) 1007 error ("-fno-gnu89-inline is not supported"); 1008 1009 /* If we are given more than one input file, we must use 1010 unit-at-a-time mode. */ 1011 if (num_in_fnames > 1) 1012 flag_unit_at_a_time = 1; 1013 1014 /* Default to ObjC sjlj exception handling if NeXT runtime. */ 1015 if (flag_objc_sjlj_exceptions < 0) 1016 flag_objc_sjlj_exceptions = flag_next_runtime; 1017 if (flag_objc_exceptions && !flag_objc_sjlj_exceptions) 1018 flag_exceptions = 1; 1019 1020 /* -Wextra implies -Wsign-compare and -Wmissing-field-initializers, 1021 but not if explicitly overridden. */ 1022 if (warn_sign_compare == -1) 1023 warn_sign_compare = extra_warnings; 1024 if (warn_missing_field_initializers == -1) 1025 warn_missing_field_initializers = extra_warnings; 1026 1027 /* -Wpointer_sign is disabled by default, but it is enabled if any 1028 of -Wall or -pedantic are given. */ 1029 if (warn_pointer_sign == -1) 1030 warn_pointer_sign = 0; 1031 1032 /* Special format checking options don't work without -Wformat; warn if 1033 they are used. */ 1034 if (!warn_format) 1035 { 1036 warning (OPT_Wformat_y2k, 1037 "-Wformat-y2k ignored without -Wformat"); 1038 warning (OPT_Wformat_extra_args, 1039 "-Wformat-extra-args ignored without -Wformat"); 1040 warning (OPT_Wformat_zero_length, 1041 "-Wformat-zero-length ignored without -Wformat"); 1042 warning (OPT_Wformat_nonliteral, 1043 "-Wformat-nonliteral ignored without -Wformat"); 1044 warning (OPT_Wformat_security, 1045 "-Wformat-security ignored without -Wformat"); 1046 } 1047 1048 /* C99 requires special handling of complex multiplication and division; 1049 -ffast-math and -fcx-limited-range are handled in process_options. */ 1050 if (flag_isoc99) 1051 flag_complex_method = 2; 1052 1053 if (flag_preprocess_only) 1054 { 1055 /* Open the output now. We must do so even if flag_no_output is 1056 on, because there may be other output than from the actual 1057 preprocessing (e.g. from -dM). */ 1058 if (out_fname[0] == '\0') 1059 out_stream = stdout; 1060 else 1061 out_stream = fopen (out_fname, "w"); 1062 1063 if (out_stream == NULL) 1064 { 1065 fatal_error ("opening output file %s: %m", out_fname); 1066 return false; 1067 } 1068 1069 if (num_in_fnames > 1) 1070 error ("too many filenames given. Type %s --help for usage", 1071 progname); 1072 1073 init_pp_output (out_stream); 1074 } 1075 else 1076 { 1077 init_c_lex (); 1078 1079 /* Yuk. WTF is this? I do know ObjC relies on it somewhere. */ 1080 input_location = UNKNOWN_LOCATION; 1081 } 1082 1083 cb = cpp_get_callbacks (parse_in); 1084 cb->file_change = cb_file_change; 1085 cb->dir_change = cb_dir_change; 1086 cpp_post_options (parse_in); 1087 1088 input_location = UNKNOWN_LOCATION; 1089 1090 /* If an error has occurred in cpplib, note it so we fail 1091 immediately. */ 1092 errorcount += cpp_errors (parse_in); 1093 1094 *pfilename = this_input_filename 1095 = cpp_read_main_file (parse_in, in_fnames[0]); 1096 /* Don't do any compilation or preprocessing if there is no input file. */ 1097 if (this_input_filename == NULL) 1098 { 1099 errorcount++; 1100 return false; 1101 } 1102 1103 if (flag_working_directory 1104 && flag_preprocess_only && !flag_no_line_commands) 1105 pp_dir_change (parse_in, get_src_pwd ()); 1106 1107 return flag_preprocess_only; 1108} 1109 1110/* Front end initialization common to C, ObjC and C++. */ 1111bool 1112c_common_init (void) 1113{ 1114 /* Set up preprocessor arithmetic. Must be done after call to 1115 c_common_nodes_and_builtins for type nodes to be good. */ 1116 cpp_opts->precision = TYPE_PRECISION (intmax_type_node); 1117 cpp_opts->char_precision = TYPE_PRECISION (char_type_node); 1118 cpp_opts->int_precision = TYPE_PRECISION (integer_type_node); 1119 cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node); 1120 cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node); 1121 cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN; 1122 1123 /* This can't happen until after wchar_precision and bytes_big_endian 1124 are known. */ 1125 cpp_init_iconv (parse_in); 1126 1127 if (version_flag) 1128 c_common_print_pch_checksum (stderr); 1129 1130 if (flag_preprocess_only) 1131 { 1132 finish_options (); 1133 preprocess_file (parse_in); 1134 return false; 1135 } 1136 1137 /* Has to wait until now so that cpplib has its hash table. */ 1138 init_pragma (); 1139 1140 return true; 1141} 1142 1143/* Initialize the integrated preprocessor after debug output has been 1144 initialized; loop over each input file. */ 1145void 1146c_common_parse_file (int set_yydebug) 1147{ 1148 unsigned int i; 1149 1150 /* Enable parser debugging, if requested and we can. If requested 1151 and we can't, notify the user. */ 1152#if YYDEBUG != 0 1153 yydebug = set_yydebug; 1154#else 1155 if (set_yydebug) 1156 warning (0, "YYDEBUG was not defined at build time, -dy ignored"); 1157#endif 1158 1159 i = 0; 1160 for (;;) 1161 { 1162 /* Start the main input file, if the debug writer wants it. */ 1163 if (debug_hooks->start_end_main_source_file) 1164 (*debug_hooks->start_source_file) (0, this_input_filename); 1165 finish_options (); 1166 pch_init (); 1167 push_file_scope (); 1168 c_parse_file (); 1169 finish_file (); 1170 pop_file_scope (); 1171 /* And end the main input file, if the debug writer wants it */ 1172 if (debug_hooks->start_end_main_source_file) 1173 (*debug_hooks->end_source_file) (0); 1174 if (++i >= num_in_fnames) 1175 break; 1176 cpp_undef_all (parse_in); 1177 this_input_filename 1178 = cpp_read_main_file (parse_in, in_fnames[i]); 1179 /* If an input file is missing, abandon further compilation. 1180 cpplib has issued a diagnostic. */ 1181 if (!this_input_filename) 1182 break; 1183 } 1184} 1185 1186/* Common finish hook for the C, ObjC and C++ front ends. */ 1187void 1188c_common_finish (void) 1189{ 1190 FILE *deps_stream = NULL; 1191 1192 if (cpp_opts->deps.style != DEPS_NONE) 1193 { 1194 /* If -M or -MM was seen without -MF, default output to the 1195 output stream. */ 1196 if (!deps_file) 1197 deps_stream = out_stream; 1198 else 1199 { 1200 deps_stream = fopen (deps_file, deps_append ? "a": "w"); 1201 if (!deps_stream) 1202 fatal_error ("opening dependency file %s: %m", deps_file); 1203 } 1204 } 1205 1206 /* For performance, avoid tearing down cpplib's internal structures 1207 with cpp_destroy (). */ 1208 errorcount += cpp_finish (parse_in, deps_stream); 1209 1210 if (deps_stream && deps_stream != out_stream 1211 && (ferror (deps_stream) || fclose (deps_stream))) 1212 fatal_error ("closing dependency file %s: %m", deps_file); 1213 1214 if (out_stream && (ferror (out_stream) || fclose (out_stream))) 1215 fatal_error ("when writing output to %s: %m", out_fname); 1216} 1217 1218/* Either of two environment variables can specify output of 1219 dependencies. Their value is either "OUTPUT_FILE" or "OUTPUT_FILE 1220 DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to 1221 and DEPS_TARGET is the target to mention in the deps. They also 1222 result in dependency information being appended to the output file 1223 rather than overwriting it, and like Sun's compiler 1224 SUNPRO_DEPENDENCIES suppresses the dependency on the main file. */ 1225static void 1226check_deps_environment_vars (void) 1227{ 1228 char *spec; 1229 1230 GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT"); 1231 if (spec) 1232 cpp_opts->deps.style = DEPS_USER; 1233 else 1234 { 1235 GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES"); 1236 if (spec) 1237 { 1238 cpp_opts->deps.style = DEPS_SYSTEM; 1239 cpp_opts->deps.ignore_main_file = true; 1240 } 1241 } 1242 1243 if (spec) 1244 { 1245 /* Find the space before the DEPS_TARGET, if there is one. */ 1246 char *s = strchr (spec, ' '); 1247 if (s) 1248 { 1249 /* Let the caller perform MAKE quoting. */ 1250 defer_opt (OPT_MT, s + 1); 1251 *s = '\0'; 1252 } 1253 1254 /* Command line -MF overrides environment variables and default. */ 1255 if (!deps_file) 1256 deps_file = spec; 1257 1258 deps_append = 1; 1259 deps_seen = true; 1260 } 1261} 1262 1263/* Handle deferred command line switches. */ 1264static void 1265handle_deferred_opts (void) 1266{ 1267 size_t i; 1268 struct deps *deps; 1269 1270 /* Avoid allocating the deps buffer if we don't need it. 1271 (This flag may be true without there having been -MT or -MQ 1272 options, but we'll still need the deps buffer.) */ 1273 if (!deps_seen) 1274 return; 1275 1276 deps = cpp_get_deps (parse_in); 1277 1278 for (i = 0; i < deferred_count; i++) 1279 { 1280 struct deferred_opt *opt = &deferred_opts[i]; 1281 1282 if (opt->code == OPT_MT || opt->code == OPT_MQ) 1283 deps_add_target (deps, opt->arg, opt->code == OPT_MQ); 1284 } 1285} 1286 1287/* These settings are appropriate for GCC, but not necessarily so for 1288 cpplib as a library. */ 1289static void 1290sanitize_cpp_opts (void) 1291{ 1292 /* If we don't know what style of dependencies to output, complain 1293 if any other dependency switches have been given. */ 1294 if (deps_seen && cpp_opts->deps.style == DEPS_NONE) 1295 error ("to generate dependencies you must specify either -M or -MM"); 1296 1297 /* -dM and dependencies suppress normal output; do it here so that 1298 the last -d[MDN] switch overrides earlier ones. */ 1299 if (flag_dump_macros == 'M') 1300 flag_no_output = 1; 1301 1302 /* Disable -dD, -dN and -dI if normal output is suppressed. Allow 1303 -dM since at least glibc relies on -M -dM to work. */ 1304 /* Also, flag_no_output implies flag_no_line_commands, always. */ 1305 if (flag_no_output) 1306 { 1307 if (flag_dump_macros != 'M') 1308 flag_dump_macros = 0; 1309 flag_dump_includes = 0; 1310 flag_no_line_commands = 1; 1311 } 1312 1313 cpp_opts->unsigned_char = !flag_signed_char; 1314 cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS; 1315 1316 /* We want -Wno-long-long to override -pedantic -std=non-c99 1317 and/or -Wtraditional, whatever the ordering. */ 1318 cpp_opts->warn_long_long 1319 = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional); 1320 1321 /* Similarly with -Wno-variadic-macros. No check for c99 here, since 1322 this also turns off warnings about GCCs extension. */ 1323 cpp_opts->warn_variadic_macros 1324 = warn_variadic_macros && (pedantic || warn_traditional); 1325 1326 /* If we're generating preprocessor output, emit current directory 1327 if explicitly requested or if debugging information is enabled. 1328 ??? Maybe we should only do it for debugging formats that 1329 actually output the current directory? */ 1330 if (flag_working_directory == -1) 1331 flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE); 1332} 1333 1334/* Add include path with a prefix at the front of its name. */ 1335static void 1336add_prefixed_path (const char *suffix, size_t chain) 1337{ 1338 char *path; 1339 const char *prefix; 1340 size_t prefix_len, suffix_len; 1341 1342 suffix_len = strlen (suffix); 1343 prefix = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR; 1344 prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len; 1345 1346 path = (char *) xmalloc (prefix_len + suffix_len + 1); 1347 memcpy (path, prefix, prefix_len); 1348 memcpy (path + prefix_len, suffix, suffix_len); 1349 path[prefix_len + suffix_len] = '\0'; 1350 1351 add_path (path, chain, 0, false); 1352} 1353 1354/* Handle -D, -U, -A, -imacros, and the first -include. */ 1355static void 1356finish_options (void) 1357{ 1358 if (!cpp_opts->preprocessed) 1359 { 1360 size_t i; 1361 1362 cb_file_change (parse_in, 1363 linemap_add (&line_table, LC_RENAME, 0, 1364 _("<built-in>"), 0)); 1365 1366 cpp_init_builtins (parse_in, flag_hosted); 1367 c_cpp_builtins (parse_in); 1368 1369 /* We're about to send user input to cpplib, so make it warn for 1370 things that we previously (when we sent it internal definitions) 1371 told it to not warn. 1372 1373 C99 permits implementation-defined characters in identifiers. 1374 The documented meaning of -std= is to turn off extensions that 1375 conflict with the specified standard, and since a strictly 1376 conforming program cannot contain a '$', we do not condition 1377 their acceptance on the -std= setting. */ 1378 cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99); 1379 1380 cpp_change_file (parse_in, LC_RENAME, _("<command line>")); 1381 for (i = 0; i < deferred_count; i++) 1382 { 1383 struct deferred_opt *opt = &deferred_opts[i]; 1384 1385 if (opt->code == OPT_D) 1386 cpp_define (parse_in, opt->arg); 1387 else if (opt->code == OPT_U) 1388 cpp_undef (parse_in, opt->arg); 1389 else if (opt->code == OPT_A) 1390 { 1391 if (opt->arg[0] == '-') 1392 cpp_unassert (parse_in, opt->arg + 1); 1393 else 1394 cpp_assert (parse_in, opt->arg); 1395 } 1396 } 1397 1398 /* Handle -imacros after -D and -U. */ 1399 for (i = 0; i < deferred_count; i++) 1400 { 1401 struct deferred_opt *opt = &deferred_opts[i]; 1402 1403 if (opt->code == OPT_imacros 1404 && cpp_push_include (parse_in, opt->arg)) 1405 { 1406 /* Disable push_command_line_include callback for now. */ 1407 include_cursor = deferred_count + 1; 1408 cpp_scan_nooutput (parse_in); 1409 } 1410 } 1411 } 1412 1413 include_cursor = 0; 1414 push_command_line_include (); 1415} 1416 1417/* Give CPP the next file given by -include, if any. */ 1418static void 1419push_command_line_include (void) 1420{ 1421 while (include_cursor < deferred_count) 1422 { 1423 struct deferred_opt *opt = &deferred_opts[include_cursor++]; 1424 1425 if (!cpp_opts->preprocessed && opt->code == OPT_include 1426 && cpp_push_include (parse_in, opt->arg)) 1427 return; 1428 } 1429 1430 if (include_cursor == deferred_count) 1431 { 1432 include_cursor++; 1433 /* -Wunused-macros should only warn about macros defined hereafter. */ 1434 cpp_opts->warn_unused_macros = warn_unused_macros; 1435 /* Restore the line map from <command line>. */ 1436 if (!cpp_opts->preprocessed) 1437 cpp_change_file (parse_in, LC_RENAME, this_input_filename); 1438 1439 /* Set this here so the client can change the option if it wishes, 1440 and after stacking the main file so we don't trace the main file. */ 1441 line_table.trace_includes = cpp_opts->print_include_names; 1442 } 1443} 1444 1445/* File change callback. Has to handle -include files. */ 1446static void 1447cb_file_change (cpp_reader * ARG_UNUSED (pfile), 1448 const struct line_map *new_map) 1449{ 1450 if (flag_preprocess_only) 1451 pp_file_change (new_map); 1452 else 1453 fe_file_change (new_map); 1454 1455 if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map))) 1456 push_command_line_include (); 1457} 1458 1459void 1460cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir) 1461{ 1462 if (!set_src_pwd (dir)) 1463 warning (0, "too late for # directive to set debug directory"); 1464} 1465 1466/* Set the C 89 standard (with 1994 amendments if C94, without GNU 1467 extensions if ISO). There is no concept of gnu94. */ 1468static void 1469set_std_c89 (int c94, int iso) 1470{ 1471 cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89); 1472 flag_iso = iso; 1473 flag_no_asm = iso; 1474 flag_no_gnu_keywords = iso; 1475 flag_no_nonansi_builtin = iso; 1476 flag_isoc94 = c94; 1477 flag_isoc99 = 0; 1478} 1479 1480/* Set the C 99 standard (without GNU extensions if ISO). */ 1481static void 1482set_std_c99 (int iso) 1483{ 1484 cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99); 1485 flag_no_asm = iso; 1486 flag_no_nonansi_builtin = iso; 1487 flag_iso = iso; 1488 flag_isoc99 = 1; 1489 flag_isoc94 = 1; 1490} 1491 1492/* Set the C++ 98 standard (without GNU extensions if ISO). */ 1493static void 1494set_std_cxx98 (int iso) 1495{ 1496 cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX); 1497 flag_no_gnu_keywords = iso; 1498 flag_no_nonansi_builtin = iso; 1499 flag_iso = iso; 1500} 1501 1502/* Handle setting implicit to ON. */ 1503static void 1504set_Wimplicit (int on) 1505{ 1506 warn_implicit = on; 1507 warn_implicit_int = on; 1508 if (on) 1509 { 1510 if (mesg_implicit_function_declaration != 2) 1511 mesg_implicit_function_declaration = 1; 1512 } 1513 else 1514 mesg_implicit_function_declaration = 0; 1515} 1516 1517/* Args to -d specify what to dump. Silently ignore 1518 unrecognized options; they may be aimed at toplev.c. */ 1519static void 1520handle_OPT_d (const char *arg) 1521{ 1522 char c; 1523 1524 while ((c = *arg++) != '\0') 1525 switch (c) 1526 { 1527 case 'M': /* Dump macros only. */ 1528 case 'N': /* Dump names. */ 1529 case 'D': /* Dump definitions. */ 1530 flag_dump_macros = c; 1531 break; 1532 1533 case 'I': 1534 flag_dump_includes = 1; 1535 break; 1536 } 1537} 1538