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