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