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