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