gcc/c-opts.c

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