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