gcc/c-family/c-opts.c

   1 /* C/ObjC/C++ command line option handling.
   2    Copyright (C) 2002-2013 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 3, 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 COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tree.h"
  25 #include "c-common.h"
  26 #include "c-pragma.h"
  27 #include "c-upc.h"
  28 #include "flags.h"
  29 #include "toplev.h"
  30 #include "langhooks.h"
  31 #include "diagnostic.h"
  32 #include "intl.h"
  33 #include "cppdefault.h"
  34 #include "incpath.h"
  35 #include "debug.h"              /* For debug_hooks.  */
  36 #include "opts.h"
  37 #include "options.h"
  38 #include "mkdeps.h"
  39 #include "c-target.h"
  40 #include "tm.h"                 /* For BYTES_BIG_ENDIAN,
  41                                    DOLLARS_IN_IDENTIFIERS,
  42                                    STDC_0_IN_SYSTEM_HEADERS,
  43                                    TARGET_FLT_EVAL_METHOD_NON_DEFAULT and
  44                                    TARGET_OPTF.  */
  45 #include "tm_p.h"               /* For C_COMMON_OVERRIDE_OPTIONS.  */
  46
  47 #ifndef DOLLARS_IN_IDENTIFIERS
  48 # define DOLLARS_IN_IDENTIFIERS true
  49 #endif
  50
  51 #ifndef TARGET_SYSTEM_ROOT
  52 # define TARGET_SYSTEM_ROOT NULL
  53 #endif
  54
  55 #ifndef TARGET_OPTF
  56 #define TARGET_OPTF(ARG)
  57 #endif
  58
  59 /* CPP's options.  */
  60 cpp_options *cpp_opts;
  61
  62 /* Input filename.  */
  63 static const char *this_input_filename;
  64
  65 /* Filename and stream for preprocessed output.  */
  66 static const char *out_fname;
  67 static FILE *out_stream;
  68
  69 /* Append dependencies to deps_file.  */
  70 static bool deps_append;
  71
  72 /* If dependency switches (-MF etc.) have been given.  */
  73 static bool deps_seen;
  74
  75 /* If -v seen.  */
  76 static bool verbose;
  77
  78 /* Dependency output file.  */
  79 static const char *deps_file;
  80
  81 /* The prefix given by -iprefix, if any.  */
  82 static const char *iprefix;
  83
  84 /* The multilib directory given by -imultilib, if any.  */
  85 static const char *imultilib;
  86
  87 /* The system root, if any.  Overridden by -isysroot.  */
  88 static const char *sysroot = TARGET_SYSTEM_ROOT;
  89
  90 /* Zero disables all standard directories for headers.  */
  91 static bool std_inc = true;
  92
  93 /* Zero disables the C++-specific standard directories for headers.  */
  94 static bool std_cxx_inc = true;
  95
  96 /* If the quote chain has been split by -I-.  */
  97 static bool quote_chain_split;
  98
  99 /* Number of deferred options.  */
 100 static size_t deferred_count;
 101
 102 /* Number of deferred options scanned for -include.  */
 103 static size_t include_cursor;
 104
 105 /* Whether any standard preincluded header has been preincluded.  */
 106 static bool done_preinclude;
 107
 108 static void handle_OPT_d (const char *);
 109 static void set_std_cxx98 (int);
 110 static void set_std_cxx11 (int);
 111 static void set_std_cxx1y (int);
 112 static void set_std_c89 (int, int);
 113 static void set_std_c99 (int);
 114 static void set_std_c11 (int);
 115 static void check_deps_environment_vars (void);
 116 static void handle_deferred_opts (void);
 117 static void sanitize_cpp_opts (void);
 118 static void add_prefixed_path (const char *, size_t);
 119 static void push_command_line_include (void);
 120 static void cb_file_change (cpp_reader *, const struct line_map *);
 121 static void cb_dir_change (cpp_reader *, const char *);
 122 static void c_finish_options (void);
 123
 124 #ifndef STDC_0_IN_SYSTEM_HEADERS
 125 #define STDC_0_IN_SYSTEM_HEADERS 0
 126 #endif
 127
 128 /* Holds switches parsed by c_common_handle_option (), but whose
 129    handling is deferred to c_common_post_options ().  */
 130 static void defer_opt (enum opt_code, const char *);
 131 static struct deferred_opt
 132 {
 133   enum opt_code code;
 134   const char *arg;
 135 } *deferred_opts;
 136
 137
 138 extern const unsigned int
 139 c_family_lang_mask = (CL_C | CL_CXX | CL_UPC | CL_ObjC | CL_ObjCXX);
 140
 141 /* Defer option CODE with argument ARG.  */
 142 static void
 143 defer_opt (enum opt_code code, const char *arg)
 144 {
 145   deferred_opts[deferred_count].code = code;
 146   deferred_opts[deferred_count].arg = arg;
 147   deferred_count++;
 148 }
 149
 150 /* Return language mask for option parsing.  */
 151 unsigned int
 152 c_common_option_lang_mask (void)
 153 {
 154   static const unsigned int
 155   lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX, CL_UPC};
 156   return lang_flags[c_language];
 157 }
 158
 159 /* Common diagnostics initialization.  */
 160 void
 161 c_common_initialize_diagnostics (diagnostic_context *context)
 162 {
 163   /* This is conditionalized only because that is the way the front
 164      ends used to do it.  Maybe this should be unconditional?  */
 165   if (c_dialect_cxx ())
 166     {
 167       /* By default wrap lines at 80 characters.  Is getenv
 168          ("COLUMNS") preferable?  */
 169       diagnostic_line_cutoff (context) = 80;
 170       /* By default, emit location information once for every
 171          diagnostic message.  */
 172       diagnostic_prefixing_rule (context) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 173     }
 174
 175   context->opt_permissive = OPT_fpermissive;
 176 }
 177
 178 /* Whether options from all C-family languages should be accepted
 179    quietly.  */
 180 static bool accept_all_c_family_options = false;
 181
 182 /* Return whether to complain about a wrong-language option.  */
 183 bool
 184 c_common_complain_wrong_lang_p (const struct cl_option *option)
 185 {
 186   if (accept_all_c_family_options
 187       && (option->flags & c_family_lang_mask))
 188     return false;
 189
 190   return true;
 191 }
 192
 193 /* Initialize options structure OPTS.  */
 194 void
 195 c_common_init_options_struct (struct gcc_options *opts)
 196 {
 197   opts->x_flag_exceptions = c_dialect_cxx ();
 198   opts->x_warn_pointer_arith = c_dialect_cxx ();
 199   opts->x_warn_write_strings = c_dialect_cxx ();
 200   opts->x_flag_warn_unused_result = true;
 201
 202   /* By default, C99-like requirements for complex multiply and divide.  */
 203   opts->x_flag_complex_method = 2;
 204 }
 205
 206 /* Common initialization before calling option handlers.  */
 207 void
 208 c_common_init_options (unsigned int decoded_options_count,
 209                        struct cl_decoded_option *decoded_options)
 210 {
 211   unsigned int i;
 212   struct cpp_callbacks *cb;
 213
 214   parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89,
 215                                 ident_hash, line_table);
 216   cb = cpp_get_callbacks (parse_in);
 217   cb->error = c_cpp_error;
 218
 219   cpp_opts = cpp_get_options (parse_in);
 220   cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
 221   cpp_opts->objc = c_dialect_objc ();
 222
 223   /* Reset to avoid warnings on internal definitions.  We set it just
 224      before passing on command-line options to cpplib.  */
 225   cpp_opts->warn_dollars = 0;
 226
 227   deferred_opts = XNEWVEC (struct deferred_opt, decoded_options_count);
 228
 229   if (c_language == clk_c)
 230     {
 231       /* If preprocessing assembly language, accept any of the C-family
 232          front end options since the driver may pass them through.  */
 233       for (i = 1; i < decoded_options_count; i++)
 234         if (decoded_options[i].opt_index == OPT_lang_asm)
 235           {
 236             accept_all_c_family_options = true;
 237             break;
 238           }
 239     }
 240 }
 241
 242 /* Handle switch SCODE with argument ARG.  VALUE is true, unless no-
 243    form of an -f or -W option was given.  Returns false if the switch was
 244    invalid, true if valid.  Use HANDLERS in recursive handle_option calls.  */
 245 bool
 246 c_common_handle_option (size_t scode, const char *arg, int value,
 247                         int kind, location_t loc,
 248                         const struct cl_option_handlers *handlers)
 249 {
 250   const struct cl_option *option = &cl_options[scode];
 251   enum opt_code code = (enum opt_code) scode;
 252   bool result = true;
 253
 254   /* Prevent resetting the language standard to a C dialect when the driver
 255      has already determined that we're looking at assembler input.  */
 256   bool preprocessing_asm_p = (cpp_get_options (parse_in)->lang == CLK_ASM);
 257
 258   switch (code)
 259     {
 260     default:
 261       if (cl_options[code].flags & c_family_lang_mask)
 262         {
 263           if ((option->flags & CL_TARGET)
 264               && ! targetcm.handle_c_option (scode, arg, value))
 265             result = false;
 266           break;
 267         }
 268       result = false;
 269       break;
 270
 271     case OPT__output_pch_:
 272       pch_file = arg;
 273       break;
 274
 275     case OPT_A:
 276       defer_opt (code, arg);
 277       break;
 278
 279     case OPT_C:
 280       cpp_opts->discard_comments = 0;
 281       break;
 282
 283     case OPT_CC:
 284       cpp_opts->discard_comments = 0;
 285       cpp_opts->discard_comments_in_macro_exp = 0;
 286       break;
 287
 288     case OPT_D:
 289       defer_opt (code, arg);
 290       break;
 291
 292     case OPT_H:
 293       cpp_opts->print_include_names = 1;
 294       break;
 295
 296     case OPT_F:
 297       TARGET_OPTF (xstrdup (arg));
 298       break;
 299
 300     case OPT_I:
 301       if (strcmp (arg, "-"))
 302         add_path (xstrdup (arg), BRACKET, 0, true);
 303       else
 304         {
 305           if (quote_chain_split)
 306             error ("-I- specified twice");
 307           quote_chain_split = true;
 308           split_quote_chain ();
 309           inform (input_location, "obsolete option -I- used, please use -iquote instead");
 310         }
 311       break;
 312
 313     case OPT_M:
 314     case OPT_MM:
 315       /* When doing dependencies with -M or -MM, suppress normal
 316          preprocessed output, but still do -dM etc. as software
 317          depends on this.  Preprocessed output does occur if -MD, -MMD
 318          or environment var dependency generation is used.  */
 319       cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER);
 320       flag_no_output = 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       cpp_opts->deps.need_preprocessor_output = true;
 327       deps_file = arg;
 328       break;
 329
 330     case OPT_MF:
 331       deps_seen = true;
 332       deps_file = arg;
 333       break;
 334
 335     case OPT_MG:
 336       deps_seen = true;
 337       cpp_opts->deps.missing_files = true;
 338       break;
 339
 340     case OPT_MP:
 341       deps_seen = true;
 342       cpp_opts->deps.phony_targets = true;
 343       break;
 344
 345     case OPT_MQ:
 346     case OPT_MT:
 347       deps_seen = true;
 348       defer_opt (code, arg);
 349       break;
 350
 351     case OPT_P:
 352       flag_no_line_commands = 1;
 353       break;
 354
 355     case OPT_U:
 356       defer_opt (code, arg);
 357       break;
 358
 359     case OPT_Wall:
 360       /* ??? Don't add new options here. Use LangEnabledBy in c.opt.  */
 361
 362       cpp_opts->warn_trigraphs = value;
 363       cpp_opts->warn_comments = value;
 364       cpp_opts->warn_num_sign_change = value;
 365       break;
 366
 367     case OPT_Wbuiltin_macro_redefined:
 368       cpp_opts->warn_builtin_macro_redefined = value;
 369       break;
 370
 371     case OPT_Wcomment:
 372       cpp_opts->warn_comments = value;
 373       break;
 374
 375     case OPT_Wc___compat:
 376       cpp_opts->warn_cxx_operator_names = value;
 377       break;
 378
 379     case OPT_Wdeprecated:
 380       cpp_opts->cpp_warn_deprecated = value;
 381       break;
 382
 383     case OPT_Wendif_labels:
 384       cpp_opts->warn_endif_labels = value;
 385       break;
 386
 387     case OPT_Winvalid_pch:
 388       cpp_opts->warn_invalid_pch = value;
 389       break;
 390
 391     case OPT_Wliteral_suffix:
 392       cpp_opts->warn_literal_suffix = value;
 393       break;
 394
 395     case OPT_Wlong_long:
 396       cpp_opts->cpp_warn_long_long = value;
 397       break;
 398
 399     case OPT_Wmissing_include_dirs:
 400       cpp_opts->warn_missing_include_dirs = value;
 401       break;
 402
 403     case OPT_Wmultichar:
 404       cpp_opts->warn_multichar = value;
 405       break;
 406
 407     case OPT_Wnormalized_:
 408       if (kind == DK_ERROR)
 409         {
 410           gcc_assert (!arg);
 411           inform (input_location, "-Werror=normalized=: set -Wnormalized=nfc");
 412           cpp_opts->warn_normalize = normalized_C;
 413         }
 414       else
 415         {
 416           if (!value || (arg && strcasecmp (arg, "none") == 0))
 417             cpp_opts->warn_normalize = normalized_none;
 418           else if (!arg || strcasecmp (arg, "nfkc") == 0)
 419             cpp_opts->warn_normalize = normalized_KC;
 420           else if (strcasecmp (arg, "id") == 0)
 421             cpp_opts->warn_normalize = normalized_identifier_C;
 422           else if (strcasecmp (arg, "nfc") == 0)
 423             cpp_opts->warn_normalize = normalized_C;
 424           else
 425             error ("argument %qs to %<-Wnormalized%> not recognized", arg);
 426           break;
 427         }
 428
 429     case OPT_Wtraditional:
 430       cpp_opts->cpp_warn_traditional = value;
 431       break;
 432
 433     case OPT_Wtrigraphs:
 434       cpp_opts->warn_trigraphs = value;
 435       break;
 436
 437     case OPT_Wundef:
 438       cpp_opts->warn_undef = value;
 439       break;
 440
 441     case OPT_Wunknown_pragmas:
 442       /* Set to greater than 1, so that even unknown pragmas in
 443          system headers will be warned about.  */
 444       /* ??? There is no way to handle this automatically for now.  */
 445       warn_unknown_pragmas = value * 2;
 446       break;
 447
 448     case OPT_ansi:
 449       if (!c_dialect_cxx ())
 450         set_std_c89 (false, true);
 451       else
 452         set_std_cxx98 (true);
 453       break;
 454
 455     case OPT_d:
 456       handle_OPT_d (arg);
 457       break;
 458
 459     case OPT_fcanonical_system_headers:
 460       cpp_opts->canonical_system_headers = value;
 461       break;
 462
 463     case OPT_fcond_mismatch:
 464       if (!c_dialect_cxx ())
 465         {
 466           flag_cond_mismatch = value;
 467           break;
 468         }
 469       warning (0, "switch %qs is no longer supported", option->opt_text);
 470       break;
 471
 472     case OPT_fbuiltin_:
 473       if (value)
 474         result = false;
 475       else
 476         disable_builtin_function (arg);
 477       break;
 478
 479     case OPT_fdirectives_only:
 480       cpp_opts->directives_only = value;
 481       break;
 482
 483     case OPT_fdollars_in_identifiers:
 484       cpp_opts->dollars_in_ident = value;
 485       break;
 486
 487     case OPT_ffreestanding:
 488       value = !value;
 489       /* Fall through....  */
 490     case OPT_fhosted:
 491       flag_hosted = value;
 492       flag_no_builtin = !value;
 493       break;
 494
 495     case OPT_fconstant_string_class_:
 496       constant_string_class_name = arg;
 497       break;
 498
 499     case OPT_fextended_identifiers:
 500       cpp_opts->extended_identifiers = value;
 501       break;
 502
 503     case OPT_foperator_names:
 504       cpp_opts->operator_names = value;
 505       break;
 506
 507     case OPT_fpch_deps:
 508       cpp_opts->restore_pch_deps = value;
 509       break;
 510
 511     case OPT_fpch_preprocess:
 512       flag_pch_preprocess = value;
 513       break;
 514
 515     case OPT_fpermissive:
 516       flag_permissive = value;
 517       global_dc->permissive = value;
 518       break;
 519
 520     case OPT_fpreprocessed:
 521       cpp_opts->preprocessed = value;
 522       break;
 523
 524     case OPT_fdebug_cpp:
 525       cpp_opts->debug = 1;
 526       break;
 527
 528     case OPT_ftrack_macro_expansion:
 529       if (value)
 530         value = 2;
 531       /* Fall Through.  */
 532
 533     case OPT_ftrack_macro_expansion_:
 534       if (arg && *arg != '\0')
 535         cpp_opts->track_macro_expansion = value;
 536       else
 537         cpp_opts->track_macro_expansion = 2;
 538       break;
 539
 540     case OPT_frepo:
 541       flag_use_repository = value;
 542       if (value)
 543         flag_implicit_templates = 0;
 544       break;
 545
 546     case OPT_ftabstop_:
 547       /* It is documented that we silently ignore silly values.  */
 548       if (value >= 1 && value <= 100)
 549         cpp_opts->tabstop = value;
 550       break;
 551
 552     case OPT_fexec_charset_:
 553       cpp_opts->narrow_charset = arg;
 554       break;
 555
 556     case OPT_fwide_exec_charset_:
 557       cpp_opts->wide_charset = arg;
 558       break;
 559
 560     case OPT_finput_charset_:
 561       cpp_opts->input_charset = arg;
 562       break;
 563
 564     case OPT_ftemplate_depth_:
 565       max_tinst_depth = value;
 566       break;
 567
 568     case OPT_fvisibility_inlines_hidden:
 569       visibility_options.inlines_hidden = value;
 570       break;
 571
 572     case OPT_femit_struct_debug_baseonly:
 573       set_struct_debug_option (&global_options, loc, "base");
 574       break;
 575
 576     case OPT_femit_struct_debug_reduced:
 577       set_struct_debug_option (&global_options, loc,
 578                                "dir:ord:sys,dir:gen:any,ind:base");
 579       break;
 580
 581     case OPT_femit_struct_debug_detailed_:
 582       set_struct_debug_option (&global_options, loc, arg);
 583       break;
 584
 585     case OPT_fext_numeric_literals:
 586       cpp_opts->ext_numeric_literals = value;
 587       break;
 588
 589     case OPT_idirafter:
 590       add_path (xstrdup (arg), AFTER, 0, true);
 591       break;
 592
 593     case OPT_imacros:
 594     case OPT_include:
 595       defer_opt (code, arg);
 596       break;
 597
 598     case OPT_imultilib:
 599       imultilib = arg;
 600       break;
 601
 602     case OPT_iprefix:
 603       iprefix = arg;
 604       break;
 605
 606     case OPT_iquote:
 607       add_path (xstrdup (arg), QUOTE, 0, true);
 608       break;
 609
 610     case OPT_isysroot:
 611       sysroot = arg;
 612       break;
 613
 614     case OPT_isystem:
 615       add_path (xstrdup (arg), SYSTEM, 0, true);
 616       break;
 617
 618     case OPT_iwithprefix:
 619       add_prefixed_path (arg, SYSTEM);
 620       break;
 621
 622     case OPT_iwithprefixbefore:
 623       add_prefixed_path (arg, BRACKET);
 624       break;
 625
 626     case OPT_lang_asm:
 627       cpp_set_lang (parse_in, CLK_ASM);
 628       cpp_opts->dollars_in_ident = false;
 629       break;
 630
 631     case OPT_lang_upc:
 632       cpp_set_lang (parse_in, CLK_UPC);
 633       break;
 634
 635     case OPT_fupc_instrument:
 636     case OPT_fupc_instrument_functions:
 637     case OPT_fupc_pthreads_model_tls:
 638     case OPT_fupc_threads_:
 639       /* processed in language-specific routine */
 640       break;
 641
 642     case OPT_nostdinc:
 643       std_inc = false;
 644       break;
 645
 646     case OPT_nostdinc__:
 647       std_cxx_inc = false;
 648       break;
 649
 650     case OPT_o:
 651       if (!out_fname)
 652         out_fname = arg;
 653       else
 654         error ("output filename specified twice");
 655       break;
 656
 657       /* We need to handle the -Wpedantic switch here, rather than in
 658          c_common_post_options, so that a subsequent -Wno-endif-labels
 659          is not overridden.  */
 660     case OPT_Wpedantic:
 661       cpp_opts->cpp_pedantic = 1;
 662       cpp_opts->warn_endif_labels = 1;
 663       break;
 664
 665     case OPT_print_objc_runtime_info:
 666       print_struct_values = 1;
 667       break;
 668
 669     case OPT_remap:
 670       cpp_opts->remap = 1;
 671       break;
 672
 673     case OPT_std_c__98:
 674     case OPT_std_gnu__98:
 675       if (!preprocessing_asm_p)
 676         set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
 677       break;
 678
 679     case OPT_std_c__11:
 680     case OPT_std_gnu__11:
 681       if (!preprocessing_asm_p)
 682         {
 683           set_std_cxx11 (code == OPT_std_c__11 /* ISO */);
 684           if (code == OPT_std_c__11)
 685             cpp_opts->ext_numeric_literals = 0;
 686         }
 687       break;
 688
 689     case OPT_std_c__1y:
 690     case OPT_std_gnu__1y:
 691       if (!preprocessing_asm_p)
 692         {
 693           set_std_cxx1y (code == OPT_std_c__1y /* ISO */);
 694           if (code == OPT_std_c__1y)
 695             cpp_opts->ext_numeric_literals = 0;
 696         }
 697       break;
 698
 699     case OPT_std_c90:
 700     case OPT_std_iso9899_199409:
 701       if (!preprocessing_asm_p)
 702         set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
 703       break;
 704
 705     case OPT_std_gnu90:
 706       if (!preprocessing_asm_p)
 707         set_std_c89 (false /* c94 */, false /* ISO */);
 708       break;
 709
 710     case OPT_std_c99:
 711       if (!preprocessing_asm_p)
 712         set_std_c99 (true /* ISO */);
 713       break;
 714
 715     case OPT_std_gnu99:
 716       if (!preprocessing_asm_p)
 717         set_std_c99 (false /* ISO */);
 718       break;
 719
 720     case OPT_std_c11:
 721       if (!preprocessing_asm_p)
 722         set_std_c11 (true /* ISO */);
 723       break;
 724
 725     case OPT_std_gnu11:
 726       if (!preprocessing_asm_p)
 727         set_std_c11 (false /* ISO */);
 728       break;
 729
 730     case OPT_trigraphs:
 731       cpp_opts->trigraphs = 1;
 732       break;
 733
 734     case OPT_traditional_cpp:
 735       cpp_opts->traditional = 1;
 736       break;
 737
 738     case OPT_v:
 739       verbose = true;
 740       break;
 741
 742     case OPT_Wabi:
 743       warn_psabi = value;
 744       break;
 745     }
 746
 747   switch (c_language)
 748     {
 749     case clk_c:
 750       C_handle_option_auto (&global_options, &global_options_set,
 751                             scode, arg, value,
 752                             c_family_lang_mask, kind,
 753                             loc, handlers, global_dc);
 754       break;
 755
 756     case clk_objc:
 757       ObjC_handle_option_auto (&global_options, &global_options_set,
 758                                scode, arg, value,
 759                                c_family_lang_mask, kind,
 760                                loc, handlers, global_dc);
 761       break;
 762
 763     case clk_upc:
 764       UPC_handle_option_auto (&global_options, &global_options_set,
 765                               scode, arg, value,
 766                               c_family_lang_mask, kind,
 767                               loc, handlers, global_dc);
 768       break;
 769
 770     case clk_cxx:
 771       CXX_handle_option_auto (&global_options, &global_options_set,
 772                               scode, arg, value,
 773                               c_family_lang_mask, kind,
 774                               loc, handlers, global_dc);
 775       break;
 776
 777     case clk_objcxx:
 778       ObjCXX_handle_option_auto (&global_options, &global_options_set,
 779                                  scode, arg, value,
 780                                  c_family_lang_mask, kind,
 781                                  loc, handlers, global_dc);
 782       break;
 783
 784     default:
 785       gcc_unreachable ();
 786     }
 787
 788   return result;
 789 }
 790
 791 /* Default implementation of TARGET_HANDLE_C_OPTION.  */
 792
 793 bool
 794 default_handle_c_option (size_t code ATTRIBUTE_UNUSED,
 795                          const char *arg ATTRIBUTE_UNUSED,
 796                          int value ATTRIBUTE_UNUSED)
 797 {
 798   return false;
 799 }
 800
 801 /* Post-switch processing.  */
 802 bool
 803 c_common_post_options (const char **pfilename)
 804 {
 805   struct cpp_callbacks *cb;
 806
 807   /* Canonicalize the input and output filenames.  */
 808   if (in_fnames == NULL)
 809     {
 810       in_fnames = XNEWVEC (const char *, 1);
 811       in_fnames[0] = "";
 812     }
 813   else if (strcmp (in_fnames[0], "-") == 0)
 814     in_fnames[0] = "";
 815
 816   if (out_fname == NULL || !strcmp (out_fname, "-"))
 817     out_fname = "";
 818
 819   if (cpp_opts->deps.style == DEPS_NONE)
 820     check_deps_environment_vars ();
 821
 822   handle_deferred_opts ();
 823
 824   sanitize_cpp_opts ();
 825
 826   register_include_chains (parse_in, sysroot, iprefix, imultilib,
 827                            std_inc, std_cxx_inc && c_dialect_cxx (), verbose);
 828
 829 #ifdef C_COMMON_OVERRIDE_OPTIONS
 830   /* Some machines may reject certain combinations of C
 831      language-specific options.  */
 832   C_COMMON_OVERRIDE_OPTIONS;
 833 #endif
 834
 835   /* Excess precision other than "fast" requires front-end
 836      support.  */
 837   if (c_dialect_cxx ())
 838     {
 839       if (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD
 840           && TARGET_FLT_EVAL_METHOD_NON_DEFAULT)
 841         sorry ("-fexcess-precision=standard for C++");
 842       flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
 843     }
 844   else if (flag_excess_precision_cmdline == EXCESS_PRECISION_DEFAULT)
 845     flag_excess_precision_cmdline = (flag_iso
 846                                      ? EXCESS_PRECISION_STANDARD
 847                                      : EXCESS_PRECISION_FAST);
 848
 849   /* By default we use C99 inline semantics in GNU99 or C99 mode.  C99
 850      inline semantics are not supported in GNU89 or C89 mode.  */
 851   if (flag_gnu89_inline == -1)
 852     flag_gnu89_inline = !flag_isoc99;
 853   else if (!flag_gnu89_inline && !flag_isoc99)
 854     error ("-fno-gnu89-inline is only supported in GNU99 or C99 mode");
 855
 856   /* Default to ObjC sjlj exception handling if NeXT runtime.  */
 857   if (flag_objc_sjlj_exceptions < 0)
 858     flag_objc_sjlj_exceptions = flag_next_runtime;
 859   if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
 860     flag_exceptions = 1;
 861
 862   /* -Woverlength-strings is off by default, but is enabled by -Wpedantic.
 863      It is never enabled in C++, as the minimum limit is not normative
 864      in that standard.  */
 865   if (c_dialect_cxx ())
 866     warn_overlength_strings = 0;
 867
 868   /* Wmain is enabled by default in C++ but not in C.  */
 869   /* Wmain is disabled by default for -ffreestanding (!flag_hosted),
 870      even if -Wall or -Wpedantic was given (warn_main will be 2 if set
 871      by -Wall, 1 if set by -Wmain).  */
 872   if (warn_main == -1)
 873     warn_main = (c_dialect_cxx () && flag_hosted) ? 1 : 0;
 874   else if (warn_main == 2)
 875     warn_main = flag_hosted ? 1 : 0;
 876
 877   /* In C, -Wall and -Wc++-compat enable -Wenum-compare; if it has not
 878      yet been set, it is disabled by default.  In C++, it is enabled
 879      by default.  */
 880   if (warn_enum_compare == -1)
 881     warn_enum_compare = c_dialect_cxx () ? 1 : 0;
 882
 883   /* -Wpacked-bitfield-compat is on by default for the C languages.  The
 884      warning is issued in stor-layout.c which is not part of the front-end so
 885      we need to selectively turn it on here.  */
 886   if (warn_packed_bitfield_compat == -1)
 887     warn_packed_bitfield_compat = 1;
 888
 889   /* Special format checking options don't work without -Wformat; warn if
 890      they are used.  */
 891   if (!warn_format)
 892     {
 893       warning (OPT_Wformat_y2k,
 894                "-Wformat-y2k ignored without -Wformat");
 895       warning (OPT_Wformat_extra_args,
 896                "-Wformat-extra-args ignored without -Wformat");
 897       warning (OPT_Wformat_zero_length,
 898                "-Wformat-zero-length ignored without -Wformat");
 899       warning (OPT_Wformat_nonliteral,
 900                "-Wformat-nonliteral ignored without -Wformat");
 901       warning (OPT_Wformat_contains_nul,
 902                "-Wformat-contains-nul ignored without -Wformat");
 903       warning (OPT_Wformat_security,
 904                "-Wformat-security ignored without -Wformat");
 905     }
 906
 907   /* -Wimplicit-function-declaration is enabled by default for C99.  */
 908   if (warn_implicit_function_declaration == -1)
 909     warn_implicit_function_declaration = flag_isoc99;
 910
 911   if (cxx_dialect >= cxx0x)
 912     {
 913       /* If we're allowing C++0x constructs, don't warn about C++98
 914          identifiers which are keywords in C++0x.  */
 915       warn_cxx0x_compat = 0;
 916
 917       if (warn_narrowing == -1)
 918         warn_narrowing = 1;
 919     }
 920   else if (warn_narrowing == -1)
 921     warn_narrowing = 0;
 922
 923   if (flag_extern_tls_init)
 924     {
 925 #if !defined (ASM_OUTPUT_DEF) || !SUPPORTS_WEAK
 926       /* Lazy TLS initialization for a variable in another TU requires
 927          alias and weak reference support. */
 928       if (flag_extern_tls_init > 0)
 929         sorry ("external TLS initialization functions not supported "
 930                "on this target");
 931       flag_extern_tls_init = 0;
 932 #else
 933       flag_extern_tls_init = 1;
 934 #endif
 935     }
 936
 937   if (flag_preprocess_only)
 938     {
 939       /* Open the output now.  We must do so even if flag_no_output is
 940          on, because there may be other output than from the actual
 941          preprocessing (e.g. from -dM).  */
 942       if (out_fname[0] == '\0')
 943         out_stream = stdout;
 944       else
 945         out_stream = fopen (out_fname, "w");
 946
 947       if (out_stream == NULL)
 948         {
 949           fatal_error ("opening output file %s: %m", out_fname);
 950           return false;
 951         }
 952
 953       if (num_in_fnames > 1)
 954         error ("too many filenames given.  Type %s --help for usage",
 955                progname);
 956
 957       init_pp_output (out_stream);
 958     }
 959   else
 960     {
 961       init_c_lex ();
 962
 963       /* When writing a PCH file, avoid reading some other PCH file,
 964          because the default address space slot then can't be used
 965          for the output PCH file.  */
 966       if (pch_file)
 967         {
 968           c_common_no_more_pch ();
 969           /* Only -g0 and -gdwarf* are supported with PCH, for other
 970              debug formats we warn here and refuse to load any PCH files.  */
 971           if (write_symbols != NO_DEBUG && write_symbols != DWARF2_DEBUG)
 972             warning (OPT_Wdeprecated,
 973                      "the \"%s\" debug format cannot be used with "
 974                      "pre-compiled headers", debug_type_names[write_symbols]);
 975         }
 976       else if (write_symbols != NO_DEBUG && write_symbols != DWARF2_DEBUG)
 977         c_common_no_more_pch ();
 978
 979       /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
 980       input_location = UNKNOWN_LOCATION;
 981     }
 982
 983   cb = cpp_get_callbacks (parse_in);
 984   cb->file_change = cb_file_change;
 985   cb->dir_change = cb_dir_change;
 986   cpp_post_options (parse_in);
 987
 988   input_location = UNKNOWN_LOCATION;
 989
 990   *pfilename = this_input_filename
 991     = cpp_read_main_file (parse_in, in_fnames[0]);
 992   /* Don't do any compilation or preprocessing if there is no input file.  */
 993   if (this_input_filename == NULL)
 994     {
 995       errorcount++;
 996       return false;
 997     }
 998
 999   if (flag_working_directory
1000       && flag_preprocess_only && !flag_no_line_commands)
1001     pp_dir_change (parse_in, get_src_pwd ());
1002
1003   /* Disable LTO output when outputting a precompiled header.  */
1004   if (pch_file && flag_lto)
1005     {
1006       flag_lto = 0;
1007       flag_generate_lto = 0;
1008     }
1009
1010   return flag_preprocess_only;
1011 }
1012
1013 /* Front end initialization common to C, ObjC and C++.  */
1014 bool
1015 c_common_init (void)
1016 {
1017   /* Set up preprocessor arithmetic.  Must be done after call to
1018      c_common_nodes_and_builtins for type nodes to be good.  */
1019   cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1020   cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1021   cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1022   cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1023   cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1024   cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1025
1026   /* This can't happen until after wchar_precision and bytes_big_endian
1027      are known.  */
1028   cpp_init_iconv (parse_in);
1029
1030   if (version_flag)
1031     {
1032       int i;
1033       fputs ("Compiler executable checksum: ", stderr);
1034       for (i = 0; i < 16; i++)
1035         fprintf (stderr, "%02x", executable_checksum[i]);
1036       putc ('\n', stderr);
1037     }
1038
1039   /* Has to wait until now so that cpplib has its hash table.  */
1040   init_pragma ();
1041
1042   if (flag_preprocess_only)
1043     {
1044       c_finish_options ();
1045       preprocess_file (parse_in);
1046       return false;
1047     }
1048
1049   return true;
1050 }
1051
1052 /* Initialize the integrated preprocessor after debug output has been
1053    initialized; loop over each input file.  */
1054 void
1055 c_common_parse_file (void)
1056 {
1057   unsigned int i;
1058
1059   i = 0;
1060   for (;;)
1061     {
1062       c_finish_options ();
1063       pch_init ();
1064       push_file_scope ();
1065       c_parse_file ();
1066       /* Generate UPC global initialization code, if required.  */
1067       if (c_dialect_upc ())
1068         upc_write_global_declarations ();
1069       pop_file_scope ();
1070       /* And end the main input file, if the debug writer wants it  */
1071       if (debug_hooks->start_end_main_source_file)
1072         (*debug_hooks->end_source_file) (0);
1073       if (++i >= num_in_fnames)
1074         break;
1075       cpp_undef_all (parse_in);
1076       cpp_clear_file_cache (parse_in);
1077       this_input_filename
1078         = cpp_read_main_file (parse_in, in_fnames[i]);
1079       /* If an input file is missing, abandon further compilation.
1080          cpplib has issued a diagnostic.  */
1081       if (!this_input_filename)
1082         break;
1083     }
1084 }
1085
1086 /* Common finish hook for the C, ObjC and C++ front ends.  */
1087 void
1088 c_common_finish (void)
1089 {
1090   FILE *deps_stream = NULL;
1091
1092   /* Don't write the deps file if there are errors.  */
1093   if (cpp_opts->deps.style != DEPS_NONE && !seen_error ())
1094     {
1095       /* If -M or -MM was seen without -MF, default output to the
1096          output stream.  */
1097       if (!deps_file)
1098         deps_stream = out_stream;
1099       else
1100         {
1101           deps_stream = fopen (deps_file, deps_append ? "a": "w");
1102           if (!deps_stream)
1103             fatal_error ("opening dependency file %s: %m", deps_file);
1104         }
1105     }
1106
1107   /* For performance, avoid tearing down cpplib's internal structures
1108      with cpp_destroy ().  */
1109   cpp_finish (parse_in, deps_stream);
1110
1111   if (deps_stream && deps_stream != out_stream
1112       && (ferror (deps_stream) || fclose (deps_stream)))
1113     fatal_error ("closing dependency file %s: %m", deps_file);
1114
1115   if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1116     fatal_error ("when writing output to %s: %m", out_fname);
1117 }
1118
1119 /* Either of two environment variables can specify output of
1120    dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1121    DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1122    and DEPS_TARGET is the target to mention in the deps.  They also
1123    result in dependency information being appended to the output file
1124    rather than overwriting it, and like Sun's compiler
1125    SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1126 static void
1127 check_deps_environment_vars (void)
1128 {
1129   char *spec;
1130
1131   spec = getenv ("DEPENDENCIES_OUTPUT");
1132   if (spec)
1133     cpp_opts->deps.style = DEPS_USER;
1134   else
1135     {
1136       spec = getenv ("SUNPRO_DEPENDENCIES");
1137       if (spec)
1138         {
1139           cpp_opts->deps.style = DEPS_SYSTEM;
1140           cpp_opts->deps.ignore_main_file = true;
1141         }
1142     }
1143
1144   if (spec)
1145     {
1146       /* Find the space before the DEPS_TARGET, if there is one.  */
1147       char *s = strchr (spec, ' ');
1148       if (s)
1149         {
1150           /* Let the caller perform MAKE quoting.  */
1151           defer_opt (OPT_MT, s + 1);
1152           *s = '\0';
1153         }
1154
1155       /* Command line -MF overrides environment variables and default.  */
1156       if (!deps_file)
1157         deps_file = spec;
1158
1159       deps_append = 1;
1160       deps_seen = true;
1161     }
1162 }
1163
1164 /* Handle deferred command line switches.  */
1165 static void
1166 handle_deferred_opts (void)
1167 {
1168   size_t i;
1169   struct deps *deps;
1170
1171   /* Avoid allocating the deps buffer if we don't need it.
1172      (This flag may be true without there having been -MT or -MQ
1173      options, but we'll still need the deps buffer.)  */
1174   if (!deps_seen)
1175     return;
1176
1177   deps = cpp_get_deps (parse_in);
1178
1179   for (i = 0; i < deferred_count; i++)
1180     {
1181       struct deferred_opt *opt = &deferred_opts[i];
1182
1183       if (opt->code == OPT_MT || opt->code == OPT_MQ)
1184         deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1185     }
1186 }
1187
1188 /* These settings are appropriate for GCC, but not necessarily so for
1189    cpplib as a library.  */
1190 static void
1191 sanitize_cpp_opts (void)
1192 {
1193   /* If we don't know what style of dependencies to output, complain
1194      if any other dependency switches have been given.  */
1195   if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1196     error ("to generate dependencies you must specify either -M or -MM");
1197
1198   /* -dM and dependencies suppress normal output; do it here so that
1199      the last -d[MDN] switch overrides earlier ones.  */
1200   if (flag_dump_macros == 'M')
1201     flag_no_output = 1;
1202
1203   /* By default, -fdirectives-only implies -dD.  This allows subsequent phases
1204      to perform proper macro expansion.  */
1205   if (cpp_opts->directives_only && !cpp_opts->preprocessed && !flag_dump_macros)
1206     flag_dump_macros = 'D';
1207
1208   /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1209      -dM since at least glibc relies on -M -dM to work.  */
1210   /* Also, flag_no_output implies flag_no_line_commands, always.  */
1211   if (flag_no_output)
1212     {
1213       if (flag_dump_macros != 'M')
1214         flag_dump_macros = 0;
1215       flag_dump_includes = 0;
1216       flag_no_line_commands = 1;
1217     }
1218   else if (cpp_opts->deps.missing_files)
1219     error ("-MG may only be used with -M or -MM");
1220
1221   cpp_opts->unsigned_char = !flag_signed_char;
1222   cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1223
1224   /* Wlong-long is disabled by default. It is enabled by:
1225       [-Wpedantic | -Wtraditional] -std=[gnu|c]++98 ; or
1226       [-Wpedantic | -Wtraditional] -std=non-c99 .
1227
1228       Either -Wlong-long or -Wno-long-long override any other settings.  */
1229   if (warn_long_long == -1)
1230     warn_long_long = ((pedantic || warn_traditional)
1231                       && (c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99));
1232   cpp_opts->cpp_warn_long_long = warn_long_long;
1233
1234   /* Similarly with -Wno-variadic-macros.  No check for c99 here, since
1235      this also turns off warnings about GCCs extension.  */
1236   cpp_opts->warn_variadic_macros
1237     = cpp_warn_variadic_macros && (pedantic || warn_traditional);
1238
1239   /* If we're generating preprocessor output, emit current directory
1240      if explicitly requested or if debugging information is enabled.
1241      ??? Maybe we should only do it for debugging formats that
1242      actually output the current directory?  */
1243   if (flag_working_directory == -1)
1244     flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1245
1246   if (cpp_opts->directives_only)
1247     {
1248       if (cpp_warn_unused_macros)
1249         error ("-fdirectives-only is incompatible with -Wunused_macros");
1250       if (cpp_opts->traditional)
1251         error ("-fdirectives-only is incompatible with -traditional");
1252     }
1253 }
1254
1255 /* Add include path with a prefix at the front of its name.  */
1256 static void
1257 add_prefixed_path (const char *suffix, size_t chain)
1258 {
1259   char *path;
1260   const char *prefix;
1261   size_t prefix_len, suffix_len;
1262
1263   suffix_len = strlen (suffix);
1264   prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1265   prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1266
1267   path = (char *) xmalloc (prefix_len + suffix_len + 1);
1268   memcpy (path, prefix, prefix_len);
1269   memcpy (path + prefix_len, suffix, suffix_len);
1270   path[prefix_len + suffix_len] = '\0';
1271
1272   add_path (path, chain, 0, false);
1273 }
1274
1275 /* Handle -D, -U, -A, -imacros, and the first -include.  */
1276 static void
1277 c_finish_options (void)
1278 {
1279   if (!cpp_opts->preprocessed)
1280     {
1281       size_t i;
1282
1283       {
1284         /* Make sure all of the builtins about to be declared have
1285           BUILTINS_LOCATION has their source_location.  */
1286         source_location builtins_loc = BUILTINS_LOCATION;
1287         cpp_force_token_locations (parse_in, &builtins_loc);
1288
1289         cpp_init_builtins (parse_in, flag_hosted);
1290         c_cpp_builtins (parse_in);
1291
1292         cpp_stop_forcing_token_locations (parse_in);
1293       }
1294
1295       /* We're about to send user input to cpplib, so make it warn for
1296          things that we previously (when we sent it internal definitions)
1297          told it to not warn.
1298
1299          C99 permits implementation-defined characters in identifiers.
1300          The documented meaning of -std= is to turn off extensions that
1301          conflict with the specified standard, and since a strictly
1302          conforming program cannot contain a '$', we do not condition
1303          their acceptance on the -std= setting.  */
1304       cpp_opts->warn_dollars = (cpp_opts->cpp_pedantic && !cpp_opts->c99);
1305
1306       cb_file_change (parse_in,
1307                       linemap_add (line_table, LC_RENAME, 0,
1308                                    _("<command-line>"), 0));
1309
1310       for (i = 0; i < deferred_count; i++)
1311         {
1312           struct deferred_opt *opt = &deferred_opts[i];
1313
1314           if (opt->code == OPT_D)
1315             cpp_define (parse_in, opt->arg);
1316           else if (opt->code == OPT_U)
1317             cpp_undef (parse_in, opt->arg);
1318           else if (opt->code == OPT_A)
1319             {
1320               if (opt->arg[0] == '-')
1321                 cpp_unassert (parse_in, opt->arg + 1);
1322               else
1323                 cpp_assert (parse_in, opt->arg);
1324             }
1325         }
1326
1327       /* Start the main input file, if the debug writer wants it. */
1328       if (debug_hooks->start_end_main_source_file
1329           && !flag_preprocess_only)
1330         (*debug_hooks->start_source_file) (0, this_input_filename);
1331
1332       /* Handle -imacros after -D and -U.  */
1333       for (i = 0; i < deferred_count; i++)
1334         {
1335           struct deferred_opt *opt = &deferred_opts[i];
1336
1337           if (opt->code == OPT_imacros
1338               && cpp_push_include (parse_in, opt->arg))
1339             {
1340               /* Disable push_command_line_include callback for now.  */
1341               include_cursor = deferred_count + 1;
1342               cpp_scan_nooutput (parse_in);
1343             }
1344         }
1345     }
1346   else
1347     {
1348       if (cpp_opts->directives_only)
1349         cpp_init_special_builtins (parse_in);
1350
1351       /* Start the main input file, if the debug writer wants it. */
1352       if (debug_hooks->start_end_main_source_file
1353           && !flag_preprocess_only)
1354         (*debug_hooks->start_source_file) (0, this_input_filename);
1355     }
1356
1357   include_cursor = 0;
1358   push_command_line_include ();
1359 }
1360
1361 /* Give CPP the next file given by -include, if any.  */
1362 static void
1363 push_command_line_include (void)
1364 {
1365   if (!done_preinclude)
1366     {
1367       done_preinclude = true;
1368       if (flag_hosted && std_inc && !cpp_opts->preprocessed)
1369         {
1370           const char *preinc = targetcm.c_preinclude ();
1371           if (preinc && cpp_push_default_include (parse_in, preinc))
1372             return;
1373         }
1374     }
1375
1376   pch_cpp_save_state ();
1377
1378   while (include_cursor < deferred_count)
1379     {
1380       struct deferred_opt *opt = &deferred_opts[include_cursor++];
1381
1382       if (!cpp_opts->preprocessed && opt->code == OPT_include
1383           && cpp_push_include (parse_in, opt->arg))
1384         return;
1385     }
1386
1387   if (include_cursor == deferred_count)
1388     {
1389       include_cursor++;
1390       /* -Wunused-macros should only warn about macros defined hereafter.  */
1391       cpp_opts->warn_unused_macros = cpp_warn_unused_macros;
1392       /* Restore the line map from <command line>.  */
1393       if (!cpp_opts->preprocessed)
1394         cpp_change_file (parse_in, LC_RENAME, this_input_filename);
1395
1396       /* Set this here so the client can change the option if it wishes,
1397          and after stacking the main file so we don't trace the main file.  */
1398       line_table->trace_includes = cpp_opts->print_include_names;
1399     }
1400 }
1401
1402 /* File change callback.  Has to handle -include files.  */
1403 static void
1404 cb_file_change (cpp_reader * ARG_UNUSED (pfile),
1405                 const struct line_map *new_map)
1406 {
1407   if (flag_preprocess_only)
1408     pp_file_change (new_map);
1409   else
1410     fe_file_change (new_map);
1411
1412   if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1413     {
1414       pch_cpp_save_state ();
1415       push_command_line_include ();
1416     }
1417 }
1418
1419 void
1420 cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
1421 {
1422   if (!set_src_pwd (dir))
1423     warning (0, "too late for # directive to set debug directory");
1424 }
1425
1426 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1427    extensions if ISO).  There is no concept of gnu94.  */
1428 static void
1429 set_std_c89 (int c94, int iso)
1430 {
1431   cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1432   flag_iso = iso;
1433   flag_no_asm = iso;
1434   flag_no_gnu_keywords = iso;
1435   flag_no_nonansi_builtin = iso;
1436   flag_isoc94 = c94;
1437   flag_isoc99 = 0;
1438   flag_isoc11 = 0;
1439 }
1440
1441 /* Set the C 99 standard (without GNU extensions if ISO).  */
1442 static void
1443 set_std_c99 (int iso)
1444 {
1445   cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1446   flag_no_asm = iso;
1447   flag_no_nonansi_builtin = iso;
1448   flag_iso = iso;
1449   flag_isoc11 = 0;
1450   flag_isoc99 = 1;
1451   flag_isoc94 = 1;
1452 }
1453
1454 /* Set the C 11 standard (without GNU extensions if ISO).  */
1455 static void
1456 set_std_c11 (int iso)
1457 {
1458   cpp_set_lang (parse_in, iso ? CLK_STDC11: CLK_GNUC11);
1459   flag_no_asm = iso;
1460   flag_no_nonansi_builtin = iso;
1461   flag_iso = iso;
1462   flag_isoc11 = 1;
1463   flag_isoc99 = 1;
1464   flag_isoc94 = 1;
1465 }
1466
1467 /* Set the C++ 98 standard (without GNU extensions if ISO).  */
1468 static void
1469 set_std_cxx98 (int iso)
1470 {
1471   cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1472   flag_no_gnu_keywords = iso;
1473   flag_no_nonansi_builtin = iso;
1474   flag_iso = iso;
1475   cxx_dialect = cxx98;
1476 }
1477
1478 /* Set the C++ 2011 standard (without GNU extensions if ISO).  */
1479 static void
1480 set_std_cxx11 (int iso)
1481 {
1482   cpp_set_lang (parse_in, iso ? CLK_CXX11: CLK_GNUCXX11);
1483   flag_no_gnu_keywords = iso;
1484   flag_no_nonansi_builtin = iso;
1485   flag_iso = iso;
1486   /* C++11 includes the C99 standard library.  */
1487   flag_isoc94 = 1;
1488   flag_isoc99 = 1;
1489   cxx_dialect = cxx11;
1490 }
1491
1492 /* Set the C++ 201y draft standard (without GNU extensions if ISO).  */
1493 static void
1494 set_std_cxx1y (int iso)
1495 {
1496   cpp_set_lang (parse_in, iso ? CLK_CXX11: CLK_GNUCXX11);
1497   flag_no_gnu_keywords = iso;
1498   flag_no_nonansi_builtin = iso;
1499   flag_iso = iso;
1500   /* C++11 includes the C99 standard library.  */
1501   flag_isoc94 = 1;
1502   flag_isoc99 = 1;
1503   cxx_dialect = cxx1y;
1504 }
1505
1506 /* Args to -d specify what to dump.  Silently ignore
1507    unrecognized options; they may be aimed at toplev.c.  */
1508 static void
1509 handle_OPT_d (const char *arg)
1510 {
1511   char c;
1512
1513   while ((c = *arg++) != '\0')
1514     switch (c)
1515       {
1516       case 'M':                 /* Dump macros only.  */
1517       case 'N':                 /* Dump names.  */
1518       case 'D':                 /* Dump definitions.  */
1519       case 'U':                 /* Dump used macros.  */
1520         flag_dump_macros = c;
1521         break;
1522
1523       case 'I':
1524         flag_dump_includes = 1;
1525         break;
1526       }
1527 }