gcc/c-family/c-opts.c

   1 /* C/ObjC/C++ command line option handling.
   2    Copyright (C) 2002-2014 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 "plugin.h"             /* For PLUGIN_INCLUDE_FILE event.  */
  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_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 lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX};
 155
 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_nostdinc:
 632       std_inc = false;
 633       break;
 634
 635     case OPT_nostdinc__:
 636       std_cxx_inc = false;
 637       break;
 638
 639     case OPT_o:
 640       if (!out_fname)
 641         out_fname = arg;
 642       else
 643         error ("output filename specified twice");
 644       break;
 645
 646       /* We need to handle the -Wpedantic switch here, rather than in
 647          c_common_post_options, so that a subsequent -Wno-endif-labels
 648          is not overridden.  */
 649     case OPT_Wpedantic:
 650       cpp_opts->cpp_pedantic = 1;
 651       cpp_opts->warn_endif_labels = 1;
 652       break;
 653
 654     case OPT_print_objc_runtime_info:
 655       print_struct_values = 1;
 656       break;
 657
 658     case OPT_remap:
 659       cpp_opts->remap = 1;
 660       break;
 661
 662     case OPT_std_c__98:
 663     case OPT_std_gnu__98:
 664       if (!preprocessing_asm_p)
 665         set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
 666       break;
 667
 668     case OPT_std_c__11:
 669     case OPT_std_gnu__11:
 670       if (!preprocessing_asm_p)
 671         {
 672           set_std_cxx11 (code == OPT_std_c__11 /* ISO */);
 673           if (code == OPT_std_c__11)
 674             cpp_opts->ext_numeric_literals = 0;
 675         }
 676       break;
 677
 678     case OPT_std_c__1y:
 679     case OPT_std_gnu__1y:
 680       if (!preprocessing_asm_p)
 681         {
 682           set_std_cxx1y (code == OPT_std_c__1y /* ISO */);
 683           if (code == OPT_std_c__1y)
 684             cpp_opts->ext_numeric_literals = 0;
 685         }
 686       break;
 687
 688     case OPT_std_c90:
 689     case OPT_std_iso9899_199409:
 690       if (!preprocessing_asm_p)
 691         set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
 692       break;
 693
 694     case OPT_std_gnu90:
 695       if (!preprocessing_asm_p)
 696         set_std_c89 (false /* c94 */, false /* ISO */);
 697       break;
 698
 699     case OPT_std_c99:
 700       if (!preprocessing_asm_p)
 701         set_std_c99 (true /* ISO */);
 702       break;
 703
 704     case OPT_std_gnu99:
 705       if (!preprocessing_asm_p)
 706         set_std_c99 (false /* ISO */);
 707       break;
 708
 709     case OPT_std_c11:
 710       if (!preprocessing_asm_p)
 711         set_std_c11 (true /* ISO */);
 712       break;
 713
 714     case OPT_std_gnu11:
 715       if (!preprocessing_asm_p)
 716         set_std_c11 (false /* ISO */);
 717       break;
 718
 719     case OPT_trigraphs:
 720       cpp_opts->trigraphs = 1;
 721       break;
 722
 723     case OPT_traditional_cpp:
 724       cpp_opts->traditional = 1;
 725       break;
 726
 727     case OPT_v:
 728       verbose = true;
 729       break;
 730
 731     case OPT_Wabi:
 732       warn_psabi = value;
 733       break;
 734     }
 735
 736   switch (c_language)
 737     {
 738     case clk_c:
 739       C_handle_option_auto (&global_options, &global_options_set,
 740                             scode, arg, value,
 741                             c_family_lang_mask, kind,
 742                             loc, handlers, global_dc);
 743       break;
 744
 745     case clk_objc:
 746       ObjC_handle_option_auto (&global_options, &global_options_set,
 747                                scode, arg, value,
 748                                c_family_lang_mask, kind,
 749                                loc, handlers, global_dc);
 750       break;
 751
 752     case clk_cxx:
 753       CXX_handle_option_auto (&global_options, &global_options_set,
 754                               scode, arg, value,
 755                               c_family_lang_mask, kind,
 756                               loc, handlers, global_dc);
 757       break;
 758
 759     case clk_objcxx:
 760       ObjCXX_handle_option_auto (&global_options, &global_options_set,
 761                                  scode, arg, value,
 762                                  c_family_lang_mask, kind,
 763                                  loc, handlers, global_dc);
 764       break;
 765
 766     default:
 767       gcc_unreachable ();
 768     }
 769
 770   return result;
 771 }
 772
 773 /* Default implementation of TARGET_HANDLE_C_OPTION.  */
 774
 775 bool
 776 default_handle_c_option (size_t code ATTRIBUTE_UNUSED,
 777                          const char *arg ATTRIBUTE_UNUSED,
 778                          int value ATTRIBUTE_UNUSED)
 779 {
 780   return false;
 781 }
 782
 783 /* Post-switch processing.  */
 784 bool
 785 c_common_post_options (const char **pfilename)
 786 {
 787   struct cpp_callbacks *cb;
 788
 789   /* Canonicalize the input and output filenames.  */
 790   if (in_fnames == NULL)
 791     {
 792       in_fnames = XNEWVEC (const char *, 1);
 793       in_fnames[0] = "";
 794     }
 795   else if (strcmp (in_fnames[0], "-") == 0)
 796     in_fnames[0] = "";
 797
 798   if (out_fname == NULL || !strcmp (out_fname, "-"))
 799     out_fname = "";
 800
 801   if (cpp_opts->deps.style == DEPS_NONE)
 802     check_deps_environment_vars ();
 803
 804   handle_deferred_opts ();
 805
 806   sanitize_cpp_opts ();
 807
 808   register_include_chains (parse_in, sysroot, iprefix, imultilib,
 809                            std_inc, std_cxx_inc && c_dialect_cxx (), verbose);
 810
 811 #ifdef C_COMMON_OVERRIDE_OPTIONS
 812   /* Some machines may reject certain combinations of C
 813      language-specific options.  */
 814   C_COMMON_OVERRIDE_OPTIONS;
 815 #endif
 816
 817   /* Excess precision other than "fast" requires front-end
 818      support.  */
 819   if (c_dialect_cxx ())
 820     {
 821       if (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD
 822           && TARGET_FLT_EVAL_METHOD_NON_DEFAULT)
 823         sorry ("-fexcess-precision=standard for C++");
 824       flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
 825     }
 826   else if (flag_excess_precision_cmdline == EXCESS_PRECISION_DEFAULT)
 827     flag_excess_precision_cmdline = (flag_iso
 828                                      ? EXCESS_PRECISION_STANDARD
 829                                      : EXCESS_PRECISION_FAST);
 830
 831   /* ISO C restricts floating-point expression contraction to within
 832      source-language expressions (-ffp-contract=on, currently an alias
 833      for -ffp-contract=off).  */
 834   if (flag_iso
 835       && !c_dialect_cxx ()
 836       && (global_options_set.x_flag_fp_contract_mode
 837           == (enum fp_contract_mode) 0))
 838     flag_fp_contract_mode = FP_CONTRACT_OFF;
 839
 840   /* By default we use C99 inline semantics in GNU99 or C99 mode.  C99
 841      inline semantics are not supported in GNU89 or C89 mode.  */
 842   if (flag_gnu89_inline == -1)
 843     flag_gnu89_inline = !flag_isoc99;
 844   else if (!flag_gnu89_inline && !flag_isoc99)
 845     error ("-fno-gnu89-inline is only supported in GNU99 or C99 mode");
 846
 847   /* Default to ObjC sjlj exception handling if NeXT runtime.  */
 848   if (flag_objc_sjlj_exceptions < 0)
 849     flag_objc_sjlj_exceptions = flag_next_runtime;
 850   if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
 851     flag_exceptions = 1;
 852
 853   /* -Woverlength-strings is off by default, but is enabled by -Wpedantic.
 854      It is never enabled in C++, as the minimum limit is not normative
 855      in that standard.  */
 856   if (c_dialect_cxx ())
 857     warn_overlength_strings = 0;
 858
 859   /* Wmain is enabled by default in C++ but not in C.  */
 860   /* Wmain is disabled by default for -ffreestanding (!flag_hosted),
 861      even if -Wall or -Wpedantic was given (warn_main will be 2 if set
 862      by -Wall, 1 if set by -Wmain).  */
 863   if (warn_main == -1)
 864     warn_main = (c_dialect_cxx () && flag_hosted) ? 1 : 0;
 865   else if (warn_main == 2)
 866     warn_main = flag_hosted ? 1 : 0;
 867
 868   /* In C, -Wall and -Wc++-compat enable -Wenum-compare; if it has not
 869      yet been set, it is disabled by default.  In C++, it is enabled
 870      by default.  */
 871   if (warn_enum_compare == -1)
 872     warn_enum_compare = c_dialect_cxx () ? 1 : 0;
 873
 874   /* -Wpacked-bitfield-compat is on by default for the C languages.  The
 875      warning is issued in stor-layout.c which is not part of the front-end so
 876      we need to selectively turn it on here.  */
 877   if (warn_packed_bitfield_compat == -1)
 878     warn_packed_bitfield_compat = 1;
 879
 880   /* Special format checking options don't work without -Wformat; warn if
 881      they are used.  */
 882   if (!warn_format)
 883     {
 884       warning (OPT_Wformat_y2k,
 885                "-Wformat-y2k ignored without -Wformat");
 886       warning (OPT_Wformat_extra_args,
 887                "-Wformat-extra-args ignored without -Wformat");
 888       warning (OPT_Wformat_zero_length,
 889                "-Wformat-zero-length ignored without -Wformat");
 890       warning (OPT_Wformat_nonliteral,
 891                "-Wformat-nonliteral ignored without -Wformat");
 892       warning (OPT_Wformat_contains_nul,
 893                "-Wformat-contains-nul ignored without -Wformat");
 894       warning (OPT_Wformat_security,
 895                "-Wformat-security ignored without -Wformat");
 896     }
 897
 898   /* -Wimplicit-function-declaration is enabled by default for C99.  */
 899   if (warn_implicit_function_declaration == -1)
 900     warn_implicit_function_declaration = flag_isoc99;
 901
 902   /* Declone C++ 'structors if -Os.  */
 903   if (flag_declone_ctor_dtor == -1)
 904     flag_declone_ctor_dtor = optimize_size;
 905
 906   if (cxx_dialect >= cxx11)
 907     {
 908       /* If we're allowing C++0x constructs, don't warn about C++98
 909          identifiers which are keywords in C++0x.  */
 910       warn_cxx0x_compat = 0;
 911
 912       if (warn_narrowing == -1)
 913         warn_narrowing = 1;
 914     }
 915   else if (warn_narrowing == -1)
 916     warn_narrowing = 0;
 917
 918   if (flag_extern_tls_init)
 919     {
 920 #if !defined (ASM_OUTPUT_DEF) || !SUPPORTS_WEAK
 921       /* Lazy TLS initialization for a variable in another TU requires
 922          alias and weak reference support. */
 923       if (flag_extern_tls_init > 0)
 924         sorry ("external TLS initialization functions not supported "
 925                "on this target");
 926       flag_extern_tls_init = 0;
 927 #else
 928       flag_extern_tls_init = 1;
 929 #endif
 930     }
 931
 932   if (flag_preprocess_only)
 933     {
 934       /* Open the output now.  We must do so even if flag_no_output is
 935          on, because there may be other output than from the actual
 936          preprocessing (e.g. from -dM).  */
 937       if (out_fname[0] == '\0')
 938         out_stream = stdout;
 939       else
 940         out_stream = fopen (out_fname, "w");
 941
 942       if (out_stream == NULL)
 943         {
 944           fatal_error ("opening output file %s: %m", out_fname);
 945           return false;
 946         }
 947
 948       if (num_in_fnames > 1)
 949         error ("too many filenames given.  Type %s --help for usage",
 950                progname);
 951
 952       init_pp_output (out_stream);
 953     }
 954   else
 955     {
 956       init_c_lex ();
 957
 958       /* When writing a PCH file, avoid reading some other PCH file,
 959          because the default address space slot then can't be used
 960          for the output PCH file.  */
 961       if (pch_file)
 962         {
 963           c_common_no_more_pch ();
 964           /* Only -g0 and -gdwarf* are supported with PCH, for other
 965              debug formats we warn here and refuse to load any PCH files.  */
 966           if (write_symbols != NO_DEBUG && write_symbols != DWARF2_DEBUG)
 967             warning (OPT_Wdeprecated,
 968                      "the \"%s\" debug format cannot be used with "
 969                      "pre-compiled headers", debug_type_names[write_symbols]);
 970         }
 971       else if (write_symbols != NO_DEBUG && write_symbols != DWARF2_DEBUG)
 972         c_common_no_more_pch ();
 973
 974       /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
 975       input_location = UNKNOWN_LOCATION;
 976     }
 977
 978   cb = cpp_get_callbacks (parse_in);
 979   cb->file_change = cb_file_change;
 980   cb->dir_change = cb_dir_change;
 981   cpp_post_options (parse_in);
 982
 983   input_location = UNKNOWN_LOCATION;
 984
 985   *pfilename = this_input_filename
 986     = cpp_read_main_file (parse_in, in_fnames[0]);
 987   /* Don't do any compilation or preprocessing if there is no input file.  */
 988   if (this_input_filename == NULL)
 989     {
 990       errorcount++;
 991       return false;
 992     }
 993
 994   if (flag_working_directory
 995       && flag_preprocess_only && !flag_no_line_commands)
 996     pp_dir_change (parse_in, get_src_pwd ());
 997
 998   /* Disable LTO output when outputting a precompiled header.  */
 999   if (pch_file && flag_lto)
1000     {
1001       flag_lto = 0;
1002       flag_generate_lto = 0;
1003     }
1004
1005   return flag_preprocess_only;
1006 }
1007
1008 /* Front end initialization common to C, ObjC and C++.  */
1009 bool
1010 c_common_init (void)
1011 {
1012   /* Set up preprocessor arithmetic.  Must be done after call to
1013      c_common_nodes_and_builtins for type nodes to be good.  */
1014   cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1015   cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1016   cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1017   cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1018   cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1019   cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1020
1021   /* This can't happen until after wchar_precision and bytes_big_endian
1022      are known.  */
1023   cpp_init_iconv (parse_in);
1024
1025   if (version_flag)
1026     {
1027       int i;
1028       fputs ("Compiler executable checksum: ", stderr);
1029       for (i = 0; i < 16; i++)
1030         fprintf (stderr, "%02x", executable_checksum[i]);
1031       putc ('\n', stderr);
1032     }
1033
1034   /* Has to wait until now so that cpplib has its hash table.  */
1035   init_pragma ();
1036
1037   if (flag_preprocess_only)
1038     {
1039       c_finish_options ();
1040       preprocess_file (parse_in);
1041       return false;
1042     }
1043
1044   return true;
1045 }
1046
1047 /* Initialize the integrated preprocessor after debug output has been
1048    initialized; loop over each input file.  */
1049 void
1050 c_common_parse_file (void)
1051 {
1052   unsigned int i;
1053
1054   i = 0;
1055   for (;;)
1056     {
1057       c_finish_options ();
1058       pch_init ();
1059       push_file_scope ();
1060       c_parse_file ();
1061       pop_file_scope ();
1062       /* And end the main input file, if the debug writer wants it  */
1063       if (debug_hooks->start_end_main_source_file)
1064         (*debug_hooks->end_source_file) (0);
1065       if (++i >= num_in_fnames)
1066         break;
1067       cpp_undef_all (parse_in);
1068       cpp_clear_file_cache (parse_in);
1069       this_input_filename
1070         = cpp_read_main_file (parse_in, in_fnames[i]);
1071       /* If an input file is missing, abandon further compilation.
1072          cpplib has issued a diagnostic.  */
1073       if (!this_input_filename)
1074         break;
1075     }
1076 }
1077
1078 /* Common finish hook for the C, ObjC and C++ front ends.  */
1079 void
1080 c_common_finish (void)
1081 {
1082   FILE *deps_stream = NULL;
1083
1084   /* Don't write the deps file if there are errors.  */
1085   if (cpp_opts->deps.style != DEPS_NONE && !seen_error ())
1086     {
1087       /* If -M or -MM was seen without -MF, default output to the
1088          output stream.  */
1089       if (!deps_file)
1090         deps_stream = out_stream;
1091       else
1092         {
1093           deps_stream = fopen (deps_file, deps_append ? "a": "w");
1094           if (!deps_stream)
1095             fatal_error ("opening dependency file %s: %m", deps_file);
1096         }
1097     }
1098
1099   /* For performance, avoid tearing down cpplib's internal structures
1100      with cpp_destroy ().  */
1101   cpp_finish (parse_in, deps_stream);
1102
1103   if (deps_stream && deps_stream != out_stream
1104       && (ferror (deps_stream) || fclose (deps_stream)))
1105     fatal_error ("closing dependency file %s: %m", deps_file);
1106
1107   if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1108     fatal_error ("when writing output to %s: %m", out_fname);
1109 }
1110
1111 /* Either of two environment variables can specify output of
1112    dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1113    DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1114    and DEPS_TARGET is the target to mention in the deps.  They also
1115    result in dependency information being appended to the output file
1116    rather than overwriting it, and like Sun's compiler
1117    SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1118 static void
1119 check_deps_environment_vars (void)
1120 {
1121   char *spec;
1122
1123   spec = getenv ("DEPENDENCIES_OUTPUT");
1124   if (spec)
1125     cpp_opts->deps.style = DEPS_USER;
1126   else
1127     {
1128       spec = getenv ("SUNPRO_DEPENDENCIES");
1129       if (spec)
1130         {
1131           cpp_opts->deps.style = DEPS_SYSTEM;
1132           cpp_opts->deps.ignore_main_file = true;
1133         }
1134     }
1135
1136   if (spec)
1137     {
1138       /* Find the space before the DEPS_TARGET, if there is one.  */
1139       char *s = strchr (spec, ' ');
1140       if (s)
1141         {
1142           /* Let the caller perform MAKE quoting.  */
1143           defer_opt (OPT_MT, s + 1);
1144           *s = '\0';
1145         }
1146
1147       /* Command line -MF overrides environment variables and default.  */
1148       if (!deps_file)
1149         deps_file = spec;
1150
1151       deps_append = 1;
1152       deps_seen = true;
1153     }
1154 }
1155
1156 /* Handle deferred command line switches.  */
1157 static void
1158 handle_deferred_opts (void)
1159 {
1160   size_t i;
1161   struct deps *deps;
1162
1163   /* Avoid allocating the deps buffer if we don't need it.
1164      (This flag may be true without there having been -MT or -MQ
1165      options, but we'll still need the deps buffer.)  */
1166   if (!deps_seen)
1167     return;
1168
1169   deps = cpp_get_deps (parse_in);
1170
1171   for (i = 0; i < deferred_count; i++)
1172     {
1173       struct deferred_opt *opt = &deferred_opts[i];
1174
1175       if (opt->code == OPT_MT || opt->code == OPT_MQ)
1176         deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1177     }
1178 }
1179
1180 /* These settings are appropriate for GCC, but not necessarily so for
1181    cpplib as a library.  */
1182 static void
1183 sanitize_cpp_opts (void)
1184 {
1185   /* If we don't know what style of dependencies to output, complain
1186      if any other dependency switches have been given.  */
1187   if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1188     error ("to generate dependencies you must specify either -M or -MM");
1189
1190   /* -dM and dependencies suppress normal output; do it here so that
1191      the last -d[MDN] switch overrides earlier ones.  */
1192   if (flag_dump_macros == 'M')
1193     flag_no_output = 1;
1194
1195   /* By default, -fdirectives-only implies -dD.  This allows subsequent phases
1196      to perform proper macro expansion.  */
1197   if (cpp_opts->directives_only && !cpp_opts->preprocessed && !flag_dump_macros)
1198     flag_dump_macros = 'D';
1199
1200   /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1201      -dM since at least glibc relies on -M -dM to work.  */
1202   /* Also, flag_no_output implies flag_no_line_commands, always.  */
1203   if (flag_no_output)
1204     {
1205       if (flag_dump_macros != 'M')
1206         flag_dump_macros = 0;
1207       flag_dump_includes = 0;
1208       flag_no_line_commands = 1;
1209     }
1210   else if (cpp_opts->deps.missing_files)
1211     error ("-MG may only be used with -M or -MM");
1212
1213   cpp_opts->unsigned_char = !flag_signed_char;
1214   cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1215   cpp_opts->warn_date_time = cpp_warn_date_time;
1216
1217   /* Wlong-long is disabled by default. It is enabled by:
1218       [-Wpedantic | -Wtraditional] -std=[gnu|c]++98 ; or
1219       [-Wpedantic | -Wtraditional] -std=non-c99 .
1220
1221       Either -Wlong-long or -Wno-long-long override any other settings.  */
1222   if (warn_long_long == -1)
1223     warn_long_long = ((pedantic || warn_traditional)
1224                       && (c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99));
1225   cpp_opts->cpp_warn_long_long = warn_long_long;
1226
1227   /* Similarly with -Wno-variadic-macros.  No check for c99 here, since
1228      this also turns off warnings about GCCs extension.  */
1229   cpp_opts->warn_variadic_macros
1230     = cpp_warn_variadic_macros && (pedantic || warn_traditional);
1231
1232   /* If we're generating preprocessor output, emit current directory
1233      if explicitly requested or if debugging information is enabled.
1234      ??? Maybe we should only do it for debugging formats that
1235      actually output the current directory?  */
1236   if (flag_working_directory == -1)
1237     flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1238
1239   if (cpp_opts->directives_only)
1240     {
1241       if (cpp_warn_unused_macros)
1242         error ("-fdirectives-only is incompatible with -Wunused_macros");
1243       if (cpp_opts->traditional)
1244         error ("-fdirectives-only is incompatible with -traditional");
1245     }
1246 }
1247
1248 /* Add include path with a prefix at the front of its name.  */
1249 static void
1250 add_prefixed_path (const char *suffix, size_t chain)
1251 {
1252   char *path;
1253   const char *prefix;
1254   size_t prefix_len, suffix_len;
1255
1256   suffix_len = strlen (suffix);
1257   prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1258   prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1259
1260   path = (char *) xmalloc (prefix_len + suffix_len + 1);
1261   memcpy (path, prefix, prefix_len);
1262   memcpy (path + prefix_len, suffix, suffix_len);
1263   path[prefix_len + suffix_len] = '\0';
1264
1265   add_path (path, chain, 0, false);
1266 }
1267
1268 /* Handle -D, -U, -A, -imacros, and the first -include.  */
1269 static void
1270 c_finish_options (void)
1271 {
1272   if (!cpp_opts->preprocessed)
1273     {
1274       size_t i;
1275
1276       {
1277         /* Make sure all of the builtins about to be declared have
1278           BUILTINS_LOCATION has their source_location.  */
1279         source_location builtins_loc = BUILTINS_LOCATION;
1280         cpp_force_token_locations (parse_in, &builtins_loc);
1281
1282         cpp_init_builtins (parse_in, flag_hosted);
1283         c_cpp_builtins (parse_in);
1284
1285         cpp_stop_forcing_token_locations (parse_in);
1286       }
1287
1288       /* We're about to send user input to cpplib, so make it warn for
1289          things that we previously (when we sent it internal definitions)
1290          told it to not warn.
1291
1292          C99 permits implementation-defined characters in identifiers.
1293          The documented meaning of -std= is to turn off extensions that
1294          conflict with the specified standard, and since a strictly
1295          conforming program cannot contain a '$', we do not condition
1296          their acceptance on the -std= setting.  */
1297       cpp_opts->warn_dollars = (cpp_opts->cpp_pedantic && !cpp_opts->c99);
1298
1299       cb_file_change (parse_in,
1300                       linemap_add (line_table, LC_RENAME, 0,
1301                                    _("<command-line>"), 0));
1302
1303       for (i = 0; i < deferred_count; i++)
1304         {
1305           struct deferred_opt *opt = &deferred_opts[i];
1306
1307           if (opt->code == OPT_D)
1308             cpp_define (parse_in, opt->arg);
1309           else if (opt->code == OPT_U)
1310             cpp_undef (parse_in, opt->arg);
1311           else if (opt->code == OPT_A)
1312             {
1313               if (opt->arg[0] == '-')
1314                 cpp_unassert (parse_in, opt->arg + 1);
1315               else
1316                 cpp_assert (parse_in, opt->arg);
1317             }
1318         }
1319
1320       /* Start the main input file, if the debug writer wants it. */
1321       if (debug_hooks->start_end_main_source_file
1322           && !flag_preprocess_only)
1323         (*debug_hooks->start_source_file) (0, this_input_filename);
1324
1325       /* Handle -imacros after -D and -U.  */
1326       for (i = 0; i < deferred_count; i++)
1327         {
1328           struct deferred_opt *opt = &deferred_opts[i];
1329
1330           if (opt->code == OPT_imacros
1331               && cpp_push_include (parse_in, opt->arg))
1332             {
1333               /* Disable push_command_line_include callback for now.  */
1334               include_cursor = deferred_count + 1;
1335               cpp_scan_nooutput (parse_in);
1336             }
1337         }
1338     }
1339   else
1340     {
1341       if (cpp_opts->directives_only)
1342         cpp_init_special_builtins (parse_in);
1343
1344       /* Start the main input file, if the debug writer wants it. */
1345       if (debug_hooks->start_end_main_source_file
1346           && !flag_preprocess_only)
1347         (*debug_hooks->start_source_file) (0, this_input_filename);
1348     }
1349
1350   include_cursor = 0;
1351   push_command_line_include ();
1352 }
1353
1354 /* Give CPP the next file given by -include, if any.  */
1355 static void
1356 push_command_line_include (void)
1357 {
1358   if (!done_preinclude)
1359     {
1360       done_preinclude = true;
1361       if (flag_hosted && std_inc && !cpp_opts->preprocessed)
1362         {
1363           const char *preinc = targetcm.c_preinclude ();
1364           if (preinc && cpp_push_default_include (parse_in, preinc))
1365             return;
1366         }
1367     }
1368
1369   pch_cpp_save_state ();
1370
1371   while (include_cursor < deferred_count)
1372     {
1373       struct deferred_opt *opt = &deferred_opts[include_cursor++];
1374
1375       if (!cpp_opts->preprocessed && opt->code == OPT_include
1376           && cpp_push_include (parse_in, opt->arg))
1377         return;
1378     }
1379
1380   if (include_cursor == deferred_count)
1381     {
1382       include_cursor++;
1383       /* -Wunused-macros should only warn about macros defined hereafter.  */
1384       cpp_opts->warn_unused_macros = cpp_warn_unused_macros;
1385       /* Restore the line map from <command line>.  */
1386       if (!cpp_opts->preprocessed)
1387         cpp_change_file (parse_in, LC_RENAME, this_input_filename);
1388
1389       /* Set this here so the client can change the option if it wishes,
1390          and after stacking the main file so we don't trace the main file.  */
1391       line_table->trace_includes = cpp_opts->print_include_names;
1392     }
1393 }
1394
1395 /* File change callback.  Has to handle -include files.  */
1396 static void
1397 cb_file_change (cpp_reader * ARG_UNUSED (pfile),
1398                 const struct line_map *new_map)
1399 {
1400   if (flag_preprocess_only)
1401     pp_file_change (new_map);
1402   else
1403     fe_file_change (new_map);
1404
1405   if (new_map
1406       && (new_map->reason == LC_ENTER || new_map->reason == LC_RENAME))
1407     {
1408       /* Signal to plugins that a file is included.  This could happen
1409          several times with the same file path, e.g. because of
1410          several '#include' or '#line' directives...  */
1411       invoke_plugin_callbacks
1412         (PLUGIN_INCLUDE_FILE,
1413          const_cast<char*> (ORDINARY_MAP_FILE_NAME (new_map)));
1414     }
1415
1416   if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1417     {
1418       pch_cpp_save_state ();
1419       push_command_line_include ();
1420     }
1421 }
1422
1423 void
1424 cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
1425 {
1426   if (!set_src_pwd (dir))
1427     warning (0, "too late for # directive to set debug directory");
1428 }
1429
1430 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1431    extensions if ISO).  There is no concept of gnu94.  */
1432 static void
1433 set_std_c89 (int c94, int iso)
1434 {
1435   cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1436   flag_iso = iso;
1437   flag_no_asm = iso;
1438   flag_no_gnu_keywords = iso;
1439   flag_no_nonansi_builtin = iso;
1440   flag_isoc94 = c94;
1441   flag_isoc99 = 0;
1442   flag_isoc11 = 0;
1443 }
1444
1445 /* Set the C 99 standard (without GNU extensions if ISO).  */
1446 static void
1447 set_std_c99 (int iso)
1448 {
1449   cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1450   flag_no_asm = iso;
1451   flag_no_nonansi_builtin = iso;
1452   flag_iso = iso;
1453   flag_isoc11 = 0;
1454   flag_isoc99 = 1;
1455   flag_isoc94 = 1;
1456 }
1457
1458 /* Set the C 11 standard (without GNU extensions if ISO).  */
1459 static void
1460 set_std_c11 (int iso)
1461 {
1462   cpp_set_lang (parse_in, iso ? CLK_STDC11: CLK_GNUC11);
1463   flag_no_asm = iso;
1464   flag_no_nonansi_builtin = iso;
1465   flag_iso = iso;
1466   flag_isoc11 = 1;
1467   flag_isoc99 = 1;
1468   flag_isoc94 = 1;
1469 }
1470
1471 /* Set the C++ 98 standard (without GNU extensions if ISO).  */
1472 static void
1473 set_std_cxx98 (int iso)
1474 {
1475   cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1476   flag_no_gnu_keywords = iso;
1477   flag_no_nonansi_builtin = iso;
1478   flag_iso = iso;
1479   cxx_dialect = cxx98;
1480 }
1481
1482 /* Set the C++ 2011 standard (without GNU extensions if ISO).  */
1483 static void
1484 set_std_cxx11 (int iso)
1485 {
1486   cpp_set_lang (parse_in, iso ? CLK_CXX11: CLK_GNUCXX11);
1487   flag_no_gnu_keywords = iso;
1488   flag_no_nonansi_builtin = iso;
1489   flag_iso = iso;
1490   /* C++11 includes the C99 standard library.  */
1491   flag_isoc94 = 1;
1492   flag_isoc99 = 1;
1493   cxx_dialect = cxx11;
1494 }
1495
1496 /* Set the C++ 201y draft standard (without GNU extensions if ISO).  */
1497 static void
1498 set_std_cxx1y (int iso)
1499 {
1500   cpp_set_lang (parse_in, iso ? CLK_CXX1Y: CLK_GNUCXX1Y);
1501   flag_no_gnu_keywords = iso;
1502   flag_no_nonansi_builtin = iso;
1503   flag_iso = iso;
1504   /* C++11 includes the C99 standard library.  */
1505   flag_isoc94 = 1;
1506   flag_isoc99 = 1;
1507   cxx_dialect = cxx1y;
1508 }
1509
1510 /* Args to -d specify what to dump.  Silently ignore
1511    unrecognized options; they may be aimed at toplev.c.  */
1512 static void
1513 handle_OPT_d (const char *arg)
1514 {
1515   char c;
1516
1517   while ((c = *arg++) != '\0')
1518     switch (c)
1519       {
1520       case 'M':                 /* Dump macros only.  */
1521       case 'N':                 /* Dump names.  */
1522       case 'D':                 /* Dump definitions.  */
1523       case 'U':                 /* Dump used macros.  */
1524         flag_dump_macros = c;
1525         break;
1526
1527       case 'I':
1528         flag_dump_includes = 1;
1529         break;
1530       }
1531 }