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