gcc/c-opts.c

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