gcc/c-opts.c

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