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