gcc/c-opts.c

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