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       warn_always_true = value;
 391
 392       /* Only warn about unknown pragmas that are not in system
 393          headers.  */
 394       warn_unknown_pragmas = value;
 395
 396       /* We save the value of warn_uninitialized, since if they put
 397          -Wuninitialized on the command line, we need to generate a
 398          warning about not using it without also specifying -O.  */
 399       if (warn_uninitialized != 1)
 400         warn_uninitialized = (value ? 2 : 0);
 401
 402       if (!c_dialect_cxx ())
 403         /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding
 404            can turn it off only if it's not explicit.  */
 405         warn_main = value * 2;
 406       else
 407         {
 408           /* C++-specific warnings.  */
 409           warn_nonvdtor = value;
 410           warn_reorder = value;
 411           warn_nontemplate_friend = value;
 412         }
 413
 414       cpp_opts->warn_trigraphs = value;
 415       cpp_opts->warn_comments = value;
 416       cpp_opts->warn_num_sign_change = value;
 417       cpp_opts->warn_multichar = value; /* Was C++ only.  */
 418       break;
 419
 420     case OPT_Wcomment:
 421     case OPT_Wcomments:
 422       cpp_opts->warn_comments = value;
 423       break;
 424
 425     case OPT_Wdeprecated:
 426       cpp_opts->warn_deprecated = value;
 427       break;
 428
 429     case OPT_Wdiv_by_zero:
 430       warn_div_by_zero = value;
 431       break;
 432
 433     case OPT_Wendif_labels:
 434       cpp_opts->warn_endif_labels = value;
 435       break;
 436
 437     case OPT_Werror:
 438       cpp_opts->warnings_are_errors = value;
 439       global_dc->warning_as_error_requested = value;
 440       break;
 441
 442     case OPT_Werror_implicit_function_declaration:
 443       mesg_implicit_function_declaration = 2;
 444       break;
 445
 446     case OPT_Wformat:
 447       set_Wformat (value);
 448       break;
 449
 450     case OPT_Wformat_:
 451       set_Wformat (atoi (arg));
 452       break;
 453
 454     case OPT_Wimplicit:
 455       set_Wimplicit (value);
 456       break;
 457
 458     case OPT_Wimport:
 459       /* Silently ignore for now.  */
 460       break;
 461
 462     case OPT_Winvalid_pch:
 463       cpp_opts->warn_invalid_pch = value;
 464       break;
 465
 466     case OPT_Wmain:
 467       if (value)
 468         warn_main = 1;
 469       else
 470         warn_main = -1;
 471       break;
 472
 473     case OPT_Wmissing_include_dirs:
 474       cpp_opts->warn_missing_include_dirs = value;
 475       break;
 476
 477     case OPT_Wmultichar:
 478       cpp_opts->warn_multichar = value;
 479       break;
 480
 481     case OPT_Wnormalized_:
 482       if (!value || (arg && strcasecmp (arg, "none") == 0))
 483         cpp_opts->warn_normalize = normalized_none;
 484       else if (!arg || strcasecmp (arg, "nfkc") == 0)
 485         cpp_opts->warn_normalize = normalized_KC;
 486       else if (strcasecmp (arg, "id") == 0)
 487         cpp_opts->warn_normalize = normalized_identifier_C;
 488       else if (strcasecmp (arg, "nfc") == 0)
 489         cpp_opts->warn_normalize = normalized_C;
 490       else
 491         error ("argument %qs to %<-Wnormalized%> not recognized", arg);
 492       break;
 493
 494     case OPT_Wreturn_type:
 495       warn_return_type = value;
 496       break;
 497
 498     case OPT_Wstrict_null_sentinel:
 499       warn_strict_null_sentinel = value;
 500       break;
 501
 502     case OPT_Wsystem_headers:
 503       cpp_opts->warn_system_headers = value;
 504       break;
 505
 506     case OPT_Wtraditional:
 507       cpp_opts->warn_traditional = value;
 508       break;
 509
 510     case OPT_Wtrigraphs:
 511       cpp_opts->warn_trigraphs = value;
 512       break;
 513
 514     case OPT_Wundef:
 515       cpp_opts->warn_undef = value;
 516       break;
 517
 518     case OPT_Wunknown_pragmas:
 519       /* Set to greater than 1, so that even unknown pragmas in
 520          system headers will be warned about.  */
 521       warn_unknown_pragmas = value * 2;
 522       break;
 523
 524     case OPT_Wunused_macros:
 525       warn_unused_macros = value;
 526       break;
 527
 528     case OPT_Wvariadic_macros:
 529       warn_variadic_macros = value;
 530       break;
 531
 532     case OPT_Wwrite_strings:
 533       if (!c_dialect_cxx ())
 534         flag_const_strings = value;
 535       else
 536         warn_write_strings = value;
 537       break;
 538
 539     case OPT_ansi:
 540       if (!c_dialect_cxx ())
 541         set_std_c89 (false, true);
 542       else
 543         set_std_cxx98 (true);
 544       break;
 545
 546     case OPT_d:
 547       handle_OPT_d (arg);
 548       break;
 549
 550     case OPT_fcond_mismatch:
 551       if (!c_dialect_cxx ())
 552         {
 553           flag_cond_mismatch = value;
 554           break;
 555         }
 556       /* Fall through.  */
 557
 558     case OPT_fall_virtual:
 559     case OPT_falt_external_templates:
 560     case OPT_fenum_int_equiv:
 561     case OPT_fexternal_templates:
 562     case OPT_fguiding_decls:
 563     case OPT_fhonor_std:
 564     case OPT_fhuge_objects:
 565     case OPT_flabels_ok:
 566     case OPT_fname_mangling_version_:
 567     case OPT_fnew_abi:
 568     case OPT_fnonnull_objects:
 569     case OPT_fsquangle:
 570     case OPT_fstrict_prototype:
 571     case OPT_fthis_is_variable:
 572     case OPT_fvtable_thunks:
 573     case OPT_fxref:
 574     case OPT_fvtable_gc:
 575       warning (0, "switch %qs is no longer supported", option->opt_text);
 576       break;
 577
 578     case OPT_faccess_control:
 579       flag_access_control = value;
 580       break;
 581
 582     case OPT_fasm:
 583       flag_no_asm = !value;
 584       break;
 585
 586     case OPT_fbuiltin:
 587       flag_no_builtin = !value;
 588       break;
 589
 590     case OPT_fbuiltin_:
 591       if (value)
 592         result = 0;
 593       else
 594         disable_builtin_function (arg);
 595       break;
 596
 597     case OPT_fdollars_in_identifiers:
 598       cpp_opts->dollars_in_ident = value;
 599       break;
 600
 601     case OPT_ffreestanding:
 602       value = !value;
 603       /* Fall through....  */
 604     case OPT_fhosted:
 605       flag_hosted = value;
 606       flag_no_builtin = !value;
 607       /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
 608       if (!value && warn_main == 2)
 609         warn_main = 0;
 610       break;
 611
 612     case OPT_fshort_double:
 613       flag_short_double = value;
 614       break;
 615
 616     case OPT_fshort_enums:
 617       flag_short_enums = value;
 618       break;
 619
 620     case OPT_fshort_wchar:
 621       flag_short_wchar = value;
 622       break;
 623
 624     case OPT_fsigned_bitfields:
 625       flag_signed_bitfields = value;
 626       break;
 627
 628     case OPT_fsigned_char:
 629       flag_signed_char = value;
 630       break;
 631
 632     case OPT_funsigned_bitfields:
 633       flag_signed_bitfields = !value;
 634       break;
 635
 636     case OPT_funsigned_char:
 637       flag_signed_char = !value;
 638       break;
 639
 640     case OPT_fcheck_new:
 641       flag_check_new = value;
 642       break;
 643
 644     case OPT_fconserve_space:
 645       flag_conserve_space = value;
 646       break;
 647
 648     case OPT_fconst_strings:
 649       flag_const_strings = value;
 650       break;
 651
 652     case OPT_fconstant_string_class_:
 653       constant_string_class_name = arg;
 654       break;
 655
 656     case OPT_fdefault_inline:
 657       flag_default_inline = value;
 658       break;
 659
 660     case OPT_felide_constructors:
 661       flag_elide_constructors = value;
 662       break;
 663
 664     case OPT_fenforce_eh_specs:
 665       flag_enforce_eh_specs = value;
 666       break;
 667
 668     case OPT_fextended_identifiers:
 669       cpp_opts->extended_identifiers = value;
 670       break;
 671
 672     case OPT_ffor_scope:
 673       flag_new_for_scope = value;
 674       break;
 675
 676     case OPT_fgnu_keywords:
 677       flag_no_gnu_keywords = !value;
 678       break;
 679
 680     case OPT_fgnu_runtime:
 681       flag_next_runtime = !value;
 682       break;
 683
 684     case OPT_fhandle_exceptions:
 685       warning (0, "-fhandle-exceptions has been renamed -fexceptions (and is now on by default)");
 686       flag_exceptions = value;
 687       break;
 688
 689     case OPT_fimplement_inlines:
 690       flag_implement_inlines = value;
 691       break;
 692
 693     case OPT_fimplicit_inline_templates:
 694       flag_implicit_inline_templates = value;
 695       break;
 696
 697     case OPT_fimplicit_templates:
 698       flag_implicit_templates = value;
 699       break;
 700
 701     case OPT_fms_extensions:
 702       flag_ms_extensions = value;
 703       break;
 704
 705     case OPT_fnext_runtime:
 706       flag_next_runtime = value;
 707       break;
 708
 709     case OPT_fnil_receivers:
 710       flag_nil_receivers = value;
 711       break;
 712
 713     case OPT_fnonansi_builtins:
 714       flag_no_nonansi_builtin = !value;
 715       break;
 716
 717     case OPT_foperator_names:
 718       cpp_opts->operator_names = value;
 719       break;
 720
 721     case OPT_foptional_diags:
 722       flag_optional_diags = value;
 723       break;
 724
 725     case OPT_fpch_deps:
 726       cpp_opts->restore_pch_deps = value;
 727       break;
 728
 729     case OPT_fpch_preprocess:
 730       flag_pch_preprocess = value;
 731       break;
 732
 733     case OPT_fpermissive:
 734       flag_permissive = value;
 735       break;
 736
 737     case OPT_fpreprocessed:
 738       cpp_opts->preprocessed = value;
 739       break;
 740
 741     case OPT_freplace_objc_classes:
 742       flag_replace_objc_classes = value;
 743       break;
 744
 745     case OPT_frepo:
 746       flag_use_repository = value;
 747       if (value)
 748         flag_implicit_templates = 0;
 749       break;
 750
 751     case OPT_frtti:
 752       flag_rtti = value;
 753       break;
 754
 755     case OPT_fshow_column:
 756       cpp_opts->show_column = value;
 757       break;
 758
 759     case OPT_fstats:
 760       flag_detailed_statistics = value;
 761       break;
 762
 763     case OPT_ftabstop_:
 764       /* It is documented that we silently ignore silly values.  */
 765       if (value >= 1 && value <= 100)
 766         cpp_opts->tabstop = value;
 767       break;
 768
 769     case OPT_fexec_charset_:
 770       cpp_opts->narrow_charset = arg;
 771       break;
 772
 773     case OPT_fwide_exec_charset_:
 774       cpp_opts->wide_charset = arg;
 775       break;
 776
 777     case OPT_finput_charset_:
 778       cpp_opts->input_charset = arg;
 779       break;
 780
 781     case OPT_ftemplate_depth_:
 782       max_tinst_depth = value;
 783       break;
 784
 785     case OPT_fuse_cxa_atexit:
 786       flag_use_cxa_atexit = value;
 787       break;
 788
 789     case OPT_fvisibility_inlines_hidden:
 790       visibility_options.inlines_hidden = value;
 791       break;
 792
 793     case OPT_fweak:
 794       flag_weak = value;
 795       break;
 796
 797     case OPT_fthreadsafe_statics:
 798       flag_threadsafe_statics = value;
 799       break;
 800
 801     case OPT_fzero_link:
 802       flag_zero_link = value;
 803       break;
 804
 805     case OPT_gen_decls:
 806       flag_gen_declaration = 1;
 807       break;
 808
 809     case OPT_idirafter:
 810       add_path (xstrdup (arg), AFTER, 0, true);
 811       break;
 812
 813     case OPT_imacros:
 814     case OPT_include:
 815       defer_opt (code, arg);
 816       break;
 817
 818     case OPT_iprefix:
 819       iprefix = arg;
 820       break;
 821
 822     case OPT_iquote:
 823       add_path (xstrdup (arg), QUOTE, 0, true);
 824       break;
 825
 826     case OPT_isysroot:
 827       sysroot = arg;
 828       break;
 829
 830     case OPT_isystem:
 831       add_path (xstrdup (arg), SYSTEM, 0, true);
 832       break;
 833
 834     case OPT_iwithprefix:
 835       add_prefixed_path (arg, SYSTEM);
 836       break;
 837
 838     case OPT_iwithprefixbefore:
 839       add_prefixed_path (arg, BRACKET);
 840       break;
 841
 842     case OPT_lang_asm:
 843       cpp_set_lang (parse_in, CLK_ASM);
 844       cpp_opts->dollars_in_ident = false;
 845       break;
 846
 847     case OPT_lang_fortran:
 848       lang_fortran = true;
 849       break;
 850
 851     case OPT_lang_objc:
 852       cpp_opts->objc = 1;
 853       break;
 854
 855     case OPT_nostdinc:
 856       std_inc = false;
 857       break;
 858
 859     case OPT_nostdinc__:
 860       std_cxx_inc = false;
 861       break;
 862
 863     case OPT_o:
 864       if (!out_fname)
 865         out_fname = arg;
 866       else
 867         error ("output filename specified twice");
 868       break;
 869
 870       /* We need to handle the -pedantic switches here, rather than in
 871          c_common_post_options, so that a subsequent -Wno-endif-labels
 872          is not overridden.  */
 873     case OPT_pedantic_errors:
 874       cpp_opts->pedantic_errors = 1;
 875       /* Fall through.  */
 876     case OPT_pedantic:
 877       cpp_opts->pedantic = 1;
 878       cpp_opts->warn_endif_labels = 1;
 879       break;
 880
 881     case OPT_print_objc_runtime_info:
 882       print_struct_values = 1;
 883       break;
 884
 885     case OPT_print_pch_checksum:
 886       c_common_print_pch_checksum (stdout);
 887       exit_after_options = true;
 888       break;
 889
 890     case OPT_remap:
 891       cpp_opts->remap = 1;
 892       break;
 893
 894     case OPT_std_c__98:
 895     case OPT_std_gnu__98:
 896       set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
 897       break;
 898
 899     case OPT_std_c89:
 900     case OPT_std_iso9899_1990:
 901     case OPT_std_iso9899_199409:
 902       set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
 903       break;
 904
 905     case OPT_std_gnu89:
 906       set_std_c89 (false /* c94 */, false /* ISO */);
 907       break;
 908
 909     case OPT_std_c99:
 910     case OPT_std_c9x:
 911     case OPT_std_iso9899_1999:
 912     case OPT_std_iso9899_199x:
 913       set_std_c99 (true /* ISO */);
 914       break;
 915
 916     case OPT_std_gnu99:
 917     case OPT_std_gnu9x:
 918       set_std_c99 (false /* ISO */);
 919       break;
 920
 921     case OPT_trigraphs:
 922       cpp_opts->trigraphs = 1;
 923       break;
 924
 925     case OPT_traditional_cpp:
 926       cpp_opts->traditional = 1;
 927       break;
 928
 929     case OPT_undef:
 930       flag_undef = 1;
 931       break;
 932
 933     case OPT_w:
 934       cpp_opts->inhibit_warnings = 1;
 935       break;
 936
 937     case OPT_v:
 938       verbose = true;
 939       break;
 940     }
 941
 942   return result;
 943 }
 944
 945 /* Post-switch processing.  */
 946 bool
 947 c_common_post_options (const char **pfilename)
 948 {
 949   struct cpp_callbacks *cb;
 950
 951   /* Canonicalize the input and output filenames.  */
 952   if (in_fnames == NULL)
 953     {
 954       in_fnames = XNEWVEC (const char *, 1);
 955       in_fnames[0] = "";
 956     }
 957   else if (strcmp (in_fnames[0], "-") == 0)
 958     in_fnames[0] = "";
 959
 960   if (out_fname == NULL || !strcmp (out_fname, "-"))
 961     out_fname = "";
 962
 963   if (cpp_opts->deps.style == DEPS_NONE)
 964     check_deps_environment_vars ();
 965
 966   handle_deferred_opts ();
 967
 968   sanitize_cpp_opts ();
 969
 970   register_include_chains (parse_in, sysroot, iprefix,
 971                            std_inc, std_cxx_inc && c_dialect_cxx (), verbose);
 972
 973   flag_inline_trees = 1;
 974
 975   /* Use tree inlining.  */
 976   if (!flag_no_inline)
 977     flag_no_inline = 1;
 978   if (flag_inline_functions)
 979     flag_inline_trees = 2;
 980
 981   /* If we are given more than one input file, we must use
 982      unit-at-a-time mode.  */
 983   if (num_in_fnames > 1)
 984     flag_unit_at_a_time = 1;
 985
 986   /* Default to ObjC sjlj exception handling if NeXT runtime.  */
 987   if (flag_objc_sjlj_exceptions < 0)
 988     flag_objc_sjlj_exceptions = flag_next_runtime;
 989   if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
 990     flag_exceptions = 1;
 991
 992   /* -Wextra implies -Wsign-compare and -Wmissing-field-initializers,
 993      but not if explicitly overridden.  */
 994   if (warn_sign_compare == -1)
 995     warn_sign_compare = extra_warnings;
 996   if (warn_missing_field_initializers == -1)
 997     warn_missing_field_initializers = extra_warnings;
 998
 999   /* Special format checking options don't work without -Wformat; warn if
1000      they are used.  */
1001   if (!warn_format)
1002     {
1003       warning (OPT_Wformat_y2k,
1004                "-Wformat-y2k ignored without -Wformat");
1005       warning (OPT_Wformat_extra_args,
1006                "-Wformat-extra-args ignored without -Wformat");
1007       warning (OPT_Wformat_zero_length,
1008                "-Wformat-zero-length ignored without -Wformat");
1009       warning (OPT_Wformat_nonliteral,
1010                "-Wformat-nonliteral ignored without -Wformat");
1011       warning (OPT_Wformat_security,
1012                "-Wformat-security ignored without -Wformat");
1013     }
1014
1015   /* C99 requires special handling of complex multiplication and division;
1016      -ffast-math and -fcx-limited-range are handled in process_options.  */
1017   if (flag_isoc99)
1018     flag_complex_method = 2;
1019
1020   if (flag_preprocess_only)
1021     {
1022       /* Open the output now.  We must do so even if flag_no_output is
1023          on, because there may be other output than from the actual
1024          preprocessing (e.g. from -dM).  */
1025       if (out_fname[0] == '\0')
1026         out_stream = stdout;
1027       else
1028         out_stream = fopen (out_fname, "w");
1029
1030       if (out_stream == NULL)
1031         {
1032           fatal_error ("opening output file %s: %m", out_fname);
1033           return false;
1034         }
1035
1036       if (num_in_fnames > 1)
1037         error ("too many filenames given.  Type %s --help for usage",
1038                progname);
1039
1040       init_pp_output (out_stream);
1041     }
1042   else
1043     {
1044       init_c_lex ();
1045
1046       /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
1047       input_location = UNKNOWN_LOCATION;
1048     }
1049
1050   cb = cpp_get_callbacks (parse_in);
1051   cb->file_change = cb_file_change;
1052   cb->dir_change = cb_dir_change;
1053   cpp_post_options (parse_in);
1054
1055   input_location = UNKNOWN_LOCATION;
1056
1057   /* If an error has occurred in cpplib, note it so we fail
1058      immediately.  */
1059   errorcount += cpp_errors (parse_in);
1060
1061   *pfilename = this_input_filename
1062     = cpp_read_main_file (parse_in, in_fnames[0]);
1063   /* Don't do any compilation or preprocessing if there is no input file.  */
1064   if (this_input_filename == NULL)
1065     {
1066       errorcount++;
1067       return false;
1068     }
1069
1070   if (flag_working_directory
1071       && flag_preprocess_only && !flag_no_line_commands)
1072     pp_dir_change (parse_in, get_src_pwd ());
1073
1074   return flag_preprocess_only;
1075 }
1076
1077 /* Front end initialization common to C, ObjC and C++.  */
1078 bool
1079 c_common_init (void)
1080 {
1081   /* Set up preprocessor arithmetic.  Must be done after call to
1082      c_common_nodes_and_builtins for type nodes to be good.  */
1083   cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1084   cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1085   cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1086   cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1087   cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1088   cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1089
1090   /* This can't happen until after wchar_precision and bytes_big_endian
1091      are known.  */
1092   cpp_init_iconv (parse_in);
1093
1094   if (version_flag)
1095     c_common_print_pch_checksum (stderr);
1096
1097   if (flag_preprocess_only)
1098     {
1099       finish_options ();
1100       preprocess_file (parse_in);
1101       return false;
1102     }
1103
1104   /* Has to wait until now so that cpplib has its hash table.  */
1105   init_pragma ();
1106
1107   return true;
1108 }
1109
1110 /* Initialize the integrated preprocessor after debug output has been
1111    initialized; loop over each input file.  */
1112 void
1113 c_common_parse_file (int set_yydebug)
1114 {
1115   unsigned int i;
1116
1117   /* Enable parser debugging, if requested and we can.  If requested
1118      and we can't, notify the user.  */
1119 #if YYDEBUG != 0
1120   yydebug = set_yydebug;
1121 #else
1122   if (set_yydebug)
1123     warning (0, "YYDEBUG was not defined at build time, -dy ignored");
1124 #endif
1125
1126   i = 0;
1127   for (;;)
1128     {
1129       /* Start the main input file, if the debug writer wants it. */
1130       if (debug_hooks->start_end_main_source_file)
1131         (*debug_hooks->start_source_file) (0, this_input_filename);
1132       finish_options ();
1133       pch_init ();
1134       push_file_scope ();
1135       c_parse_file ();
1136       finish_file ();
1137       pop_file_scope ();
1138       /* And end the main input file, if the debug writer wants it  */
1139       if (debug_hooks->start_end_main_source_file)
1140         (*debug_hooks->end_source_file) (0);
1141       if (++i >= num_in_fnames)
1142         break;
1143       cpp_undef_all (parse_in);
1144       this_input_filename
1145         = cpp_read_main_file (parse_in, in_fnames[i]);
1146       /* If an input file is missing, abandon further compilation.
1147          cpplib has issued a diagnostic.  */
1148       if (!this_input_filename)
1149         break;
1150     }
1151 }
1152
1153 /* Common finish hook for the C, ObjC and C++ front ends.  */
1154 void
1155 c_common_finish (void)
1156 {
1157   FILE *deps_stream = NULL;
1158
1159   if (cpp_opts->deps.style != DEPS_NONE)
1160     {
1161       /* If -M or -MM was seen without -MF, default output to the
1162          output stream.  */
1163       if (!deps_file)
1164         deps_stream = out_stream;
1165       else
1166         {
1167           deps_stream = fopen (deps_file, deps_append ? "a": "w");
1168           if (!deps_stream)
1169             fatal_error ("opening dependency file %s: %m", deps_file);
1170         }
1171     }
1172
1173   /* For performance, avoid tearing down cpplib's internal structures
1174      with cpp_destroy ().  */
1175   errorcount += cpp_finish (parse_in, deps_stream);
1176
1177   if (deps_stream && deps_stream != out_stream
1178       && (ferror (deps_stream) || fclose (deps_stream)))
1179     fatal_error ("closing dependency file %s: %m", deps_file);
1180
1181   if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1182     fatal_error ("when writing output to %s: %m", out_fname);
1183 }
1184
1185 /* Either of two environment variables can specify output of
1186    dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1187    DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1188    and DEPS_TARGET is the target to mention in the deps.  They also
1189    result in dependency information being appended to the output file
1190    rather than overwriting it, and like Sun's compiler
1191    SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1192 static void
1193 check_deps_environment_vars (void)
1194 {
1195   char *spec;
1196
1197   GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1198   if (spec)
1199     cpp_opts->deps.style = DEPS_USER;
1200   else
1201     {
1202       GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1203       if (spec)
1204         {
1205           cpp_opts->deps.style = DEPS_SYSTEM;
1206           cpp_opts->deps.ignore_main_file = true;
1207         }
1208     }
1209
1210   if (spec)
1211     {
1212       /* Find the space before the DEPS_TARGET, if there is one.  */
1213       char *s = strchr (spec, ' ');
1214       if (s)
1215         {
1216           /* Let the caller perform MAKE quoting.  */
1217           defer_opt (OPT_MT, s + 1);
1218           *s = '\0';
1219         }
1220
1221       /* Command line -MF overrides environment variables and default.  */
1222       if (!deps_file)
1223         deps_file = spec;
1224
1225       deps_append = 1;
1226       deps_seen = true;
1227     }
1228 }
1229
1230 /* Handle deferred command line switches.  */
1231 static void
1232 handle_deferred_opts (void)
1233 {
1234   size_t i;
1235   struct deps *deps;
1236
1237   /* Avoid allocating the deps buffer if we don't need it.
1238      (This flag may be true without there having been -MT or -MQ
1239      options, but we'll still need the deps buffer.)  */
1240   if (!deps_seen)
1241     return;
1242
1243   deps = cpp_get_deps (parse_in);
1244
1245   for (i = 0; i < deferred_count; i++)
1246     {
1247       struct deferred_opt *opt = &deferred_opts[i];
1248
1249       if (opt->code == OPT_MT || opt->code == OPT_MQ)
1250         deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1251     }
1252 }
1253
1254 /* These settings are appropriate for GCC, but not necessarily so for
1255    cpplib as a library.  */
1256 static void
1257 sanitize_cpp_opts (void)
1258 {
1259   /* If we don't know what style of dependencies to output, complain
1260      if any other dependency switches have been given.  */
1261   if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1262     error ("to generate dependencies you must specify either -M or -MM");
1263
1264   /* -dM and dependencies suppress normal output; do it here so that
1265      the last -d[MDN] switch overrides earlier ones.  */
1266   if (flag_dump_macros == 'M')
1267     flag_no_output = 1;
1268
1269   /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1270      -dM since at least glibc relies on -M -dM to work.  */
1271   /* Also, flag_no_output implies flag_no_line_commands, always.  */
1272   if (flag_no_output)
1273     {
1274       if (flag_dump_macros != 'M')
1275         flag_dump_macros = 0;
1276       flag_dump_includes = 0;
1277       flag_no_line_commands = 1;
1278     }
1279
1280   cpp_opts->unsigned_char = !flag_signed_char;
1281   cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1282
1283   /* We want -Wno-long-long to override -pedantic -std=non-c99
1284      and/or -Wtraditional, whatever the ordering.  */
1285   cpp_opts->warn_long_long
1286     = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
1287
1288   /* Similarly with -Wno-variadic-macros.  No check for c99 here, since
1289      this also turns off warnings about GCCs extension.  */
1290   cpp_opts->warn_variadic_macros
1291     = warn_variadic_macros && (pedantic || warn_traditional);
1292
1293   /* If we're generating preprocessor output, emit current directory
1294      if explicitly requested or if debugging information is enabled.
1295      ??? Maybe we should only do it for debugging formats that
1296      actually output the current directory?  */
1297   if (flag_working_directory == -1)
1298     flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1299 }
1300
1301 /* Add include path with a prefix at the front of its name.  */
1302 static void
1303 add_prefixed_path (const char *suffix, size_t chain)
1304 {
1305   char *path;
1306   const char *prefix;
1307   size_t prefix_len, suffix_len;
1308
1309   suffix_len = strlen (suffix);
1310   prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1311   prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1312
1313   path = (char *) xmalloc (prefix_len + suffix_len + 1);
1314   memcpy (path, prefix, prefix_len);
1315   memcpy (path + prefix_len, suffix, suffix_len);
1316   path[prefix_len + suffix_len] = '\0';
1317
1318   add_path (path, chain, 0, false);
1319 }
1320
1321 /* Handle -D, -U, -A, -imacros, and the first -include.  */
1322 static void
1323 finish_options (void)
1324 {
1325   if (!cpp_opts->preprocessed)
1326     {
1327       size_t i;
1328
1329       cb_file_change (parse_in,
1330                       linemap_add (&line_table, LC_RENAME, 0,
1331                                    _("<built-in>"), 0));
1332
1333       cpp_init_builtins (parse_in, flag_hosted);
1334       c_cpp_builtins (parse_in);
1335
1336       /* We're about to send user input to cpplib, so make it warn for
1337          things that we previously (when we sent it internal definitions)
1338          told it to not warn.
1339
1340          C99 permits implementation-defined characters in identifiers.
1341          The documented meaning of -std= is to turn off extensions that
1342          conflict with the specified standard, and since a strictly
1343          conforming program cannot contain a '$', we do not condition
1344          their acceptance on the -std= setting.  */
1345       cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
1346
1347       cpp_change_file (parse_in, LC_RENAME, _("<command line>"));
1348       for (i = 0; i < deferred_count; i++)
1349         {
1350           struct deferred_opt *opt = &deferred_opts[i];
1351
1352           if (opt->code == OPT_D)
1353             cpp_define (parse_in, opt->arg);
1354           else if (opt->code == OPT_U)
1355             cpp_undef (parse_in, opt->arg);
1356           else if (opt->code == OPT_A)
1357             {
1358               if (opt->arg[0] == '-')
1359                 cpp_unassert (parse_in, opt->arg + 1);
1360               else
1361                 cpp_assert (parse_in, opt->arg);
1362             }
1363         }
1364
1365       /* Handle -imacros after -D and -U.  */
1366       for (i = 0; i < deferred_count; i++)
1367         {
1368           struct deferred_opt *opt = &deferred_opts[i];
1369
1370           if (opt->code == OPT_imacros
1371               && cpp_push_include (parse_in, opt->arg))
1372             {
1373               /* Disable push_command_line_include callback for now.  */
1374               include_cursor = deferred_count + 1;
1375               cpp_scan_nooutput (parse_in);
1376             }
1377         }
1378     }
1379
1380   include_cursor = 0;
1381   push_command_line_include ();
1382 }
1383
1384 /* Give CPP the next file given by -include, if any.  */
1385 static void
1386 push_command_line_include (void)
1387 {
1388   while (include_cursor < deferred_count)
1389     {
1390       struct deferred_opt *opt = &deferred_opts[include_cursor++];
1391
1392       if (!cpp_opts->preprocessed && opt->code == OPT_include
1393           && cpp_push_include (parse_in, opt->arg))
1394         return;
1395     }
1396
1397   if (include_cursor == deferred_count)
1398     {
1399       include_cursor++;
1400       /* -Wunused-macros should only warn about macros defined hereafter.  */
1401       cpp_opts->warn_unused_macros = warn_unused_macros;
1402       /* Restore the line map from <command line>.  */
1403       if (!cpp_opts->preprocessed)
1404         cpp_change_file (parse_in, LC_RENAME, this_input_filename);
1405
1406       /* Set this here so the client can change the option if it wishes,
1407          and after stacking the main file so we don't trace the main file.  */
1408       line_table.trace_includes = cpp_opts->print_include_names;
1409     }
1410 }
1411
1412 /* File change callback.  Has to handle -include files.  */
1413 static void
1414 cb_file_change (cpp_reader * ARG_UNUSED (pfile),
1415                 const struct line_map *new_map)
1416 {
1417   if (flag_preprocess_only)
1418     pp_file_change (new_map);
1419   else
1420     fe_file_change (new_map);
1421
1422   if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1423     push_command_line_include ();
1424 }
1425
1426 void
1427 cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
1428 {
1429   if (!set_src_pwd (dir))
1430     warning (0, "too late for # directive to set debug directory");
1431 }
1432
1433 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1434    extensions if ISO).  There is no concept of gnu94.  */
1435 static void
1436 set_std_c89 (int c94, int iso)
1437 {
1438   cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1439   flag_iso = iso;
1440   flag_no_asm = iso;
1441   flag_no_gnu_keywords = iso;
1442   flag_no_nonansi_builtin = iso;
1443   flag_isoc94 = c94;
1444   flag_isoc99 = 0;
1445 }
1446
1447 /* Set the C 99 standard (without GNU extensions if ISO).  */
1448 static void
1449 set_std_c99 (int iso)
1450 {
1451   cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1452   flag_no_asm = iso;
1453   flag_no_nonansi_builtin = iso;
1454   flag_iso = iso;
1455   flag_isoc99 = 1;
1456   flag_isoc94 = 1;
1457 }
1458
1459 /* Set the C++ 98 standard (without GNU extensions if ISO).  */
1460 static void
1461 set_std_cxx98 (int iso)
1462 {
1463   cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1464   flag_no_gnu_keywords = iso;
1465   flag_no_nonansi_builtin = iso;
1466   flag_iso = iso;
1467 }
1468
1469 /* Handle setting implicit to ON.  */
1470 static void
1471 set_Wimplicit (int on)
1472 {
1473   warn_implicit = on;
1474   warn_implicit_int = on;
1475   if (on)
1476     {
1477       if (mesg_implicit_function_declaration != 2)
1478         mesg_implicit_function_declaration = 1;
1479     }
1480   else
1481     mesg_implicit_function_declaration = 0;
1482 }
1483
1484 /* Args to -d specify what to dump.  Silently ignore
1485    unrecognized options; they may be aimed at toplev.c.  */
1486 static void
1487 handle_OPT_d (const char *arg)
1488 {
1489   char c;
1490
1491   while ((c = *arg++) != '\0')
1492     switch (c)
1493       {
1494       case 'M':                 /* Dump macros only.  */
1495       case 'N':                 /* Dump names.  */
1496       case 'D':                 /* Dump definitions.  */
1497         flag_dump_macros = c;
1498         break;
1499
1500       case 'I':
1501         flag_dump_includes = 1;
1502         break;
1503       }
1504 }