gcc-4_8/gcc/c-family/c-opts.c

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