gcc/c-opts.c

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