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