gcc/c-opts.c

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