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