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