c-opts.c revision 259268
1145171Sdas/* C/ObjC/C++ command line option handling.
2145171Sdas   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
3145171Sdas   Free Software Foundation, Inc.
4145171Sdas   Contributed by Neil Booth.
5145171Sdas
6145171SdasThis file is part of GCC.
7145171Sdas
8145171SdasGCC is free software; you can redistribute it and/or modify it under
9145171Sdasthe terms of the GNU General Public License as published by the Free
10145171SdasSoftware Foundation; either version 2, or (at your option) any later
11145171Sdasversion.
12145171Sdas
13145171SdasGCC is distributed in the hope that it will be useful, but WITHOUT ANY
14145171SdasWARRANTY; without even the implied warranty of MERCHANTABILITY or
15145171SdasFITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16145171Sdasfor more details.
17145171Sdas
18145171SdasYou should have received a copy of the GNU General Public License
19145171Sdasalong with GCC; see the file COPYING.  If not, write to the Free
20145171SdasSoftware Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
21145171Sdas02110-1301, USA.  */
22145171Sdas
23145171Sdas/* $FreeBSD: stable/10/contrib/gcc/c-opts.c 259268 2013-12-12 18:15:32Z pfg $ */
24145171Sdas/* Merged C99 inline changes from gcc trunk 122565 2007-03-05 */
25145171Sdas
26145171Sdas#include "config.h"
27145171Sdas#include "system.h"
28145171Sdas#include "coretypes.h"
29145171Sdas#include "tm.h"
30145171Sdas#include "tree.h"
31145171Sdas#include "c-common.h"
32145171Sdas#include "c-pragma.h"
33145171Sdas#include "flags.h"
34145171Sdas#include "toplev.h"
35145171Sdas#include "langhooks.h"
36145171Sdas#include "tree-inline.h"
37145171Sdas#include "diagnostic.h"
38145171Sdas#include "intl.h"
39145171Sdas#include "cppdefault.h"
40192760Sattilio#include "c-incpath.h"
41217108Skib#include "debug.h"		/* For debug_hooks.  */
42217108Skib#include "opts.h"
43#include "options.h"
44#include "mkdeps.h"
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.  */
59static cpp_options *cpp_opts;
60
61/* Input filename.  */
62static const char *this_input_filename;
63
64/* Filename and stream for preprocessed output.  */
65static const char *out_fname;
66static FILE *out_stream;
67
68/* Append dependencies to deps_file.  */
69static bool deps_append;
70
71/* If dependency switches (-MF etc.) have been given.  */
72static bool deps_seen;
73
74/* If -v seen.  */
75static bool verbose;
76
77/* If -lang-fortran seen.  */
78static bool lang_fortran = false;
79
80/* Dependency output file.  */
81static const char *deps_file;
82
83/* The prefix given by -iprefix, if any.  */
84static const char *iprefix;
85
86/* The multilib directory given by -imultilib, if any.  */
87static const char *imultilib;
88
89/* The system root, if any.  Overridden by -isysroot.  */
90static const char *sysroot = TARGET_SYSTEM_ROOT;
91
92/* Zero disables all standard directories for headers.  */
93static bool std_inc = true;
94
95/* Zero disables the C++-specific standard directories for headers.  */
96static bool std_cxx_inc = true;
97
98/* If the quote chain has been split by -I-.  */
99static bool quote_chain_split;
100
101/* If -Wunused-macros.  */
102static bool warn_unused_macros;
103
104/* If -Wvariadic-macros.  */
105static bool warn_variadic_macros = true;
106
107/* Number of deferred options.  */
108static size_t deferred_count;
109
110/* Number of deferred options scanned for -include.  */
111static size_t include_cursor;
112
113static void set_Wimplicit (int);
114static void handle_OPT_d (const char *);
115static void set_std_cxx98 (int);
116static void set_std_c89 (int, int);
117static void set_std_c99 (int);
118static void check_deps_environment_vars (void);
119static void handle_deferred_opts (void);
120static void sanitize_cpp_opts (void);
121static void add_prefixed_path (const char *, size_t);
122static void push_command_line_include (void);
123static void cb_file_change (cpp_reader *, const struct line_map *);
124static void cb_dir_change (cpp_reader *, const char *);
125static void finish_options (void);
126
127#ifndef STDC_0_IN_SYSTEM_HEADERS
128#define STDC_0_IN_SYSTEM_HEADERS 0
129#endif
130
131/* Holds switches parsed by c_common_handle_option (), but whose
132   handling is deferred to c_common_post_options ().  */
133static void defer_opt (enum opt_code, const char *);
134static struct deferred_opt
135{
136  enum opt_code code;
137  const char *arg;
138} *deferred_opts;
139
140/* Complain that switch CODE expects an argument but none was
141   provided.  OPT was the command-line option.  Return FALSE to get
142   the default message in opts.c, TRUE if we provide a specialized
143   one.  */
144bool
145c_common_missing_argument (const char *opt, size_t code)
146{
147  switch (code)
148    {
149    default:
150      /* Pick up the default message.  */
151      return false;
152
153    case OPT_fconstant_string_class_:
154      error ("no class name specified with %qs", opt);
155      break;
156
157    case OPT_A:
158      error ("assertion missing after %qs", opt);
159      break;
160
161    case OPT_D:
162    case OPT_U:
163      error ("macro name missing after %qs", opt);
164      break;
165
166    case OPT_F:
167    case OPT_I:
168    case OPT_idirafter:
169    case OPT_isysroot:
170    case OPT_isystem:
171    case OPT_iquote:
172      error ("missing path after %qs", opt);
173      break;
174
175    case OPT_MF:
176    case OPT_MD:
177    case OPT_MMD:
178    case OPT_include:
179    case OPT_imacros:
180    case OPT_o:
181      error ("missing filename after %qs", opt);
182      break;
183
184    case OPT_MQ:
185    case OPT_MT:
186      error ("missing makefile target after %qs", opt);
187      break;
188    }
189
190  return true;
191}
192
193/* Defer option CODE with argument ARG.  */
194static void
195defer_opt (enum opt_code code, const char *arg)
196{
197  deferred_opts[deferred_count].code = code;
198  deferred_opts[deferred_count].arg = arg;
199  deferred_count++;
200}
201
202/* Common initialization before parsing options.  */
203unsigned int
204c_common_init_options (unsigned int argc, const char **argv)
205{
206  static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX};
207  unsigned int i, result;
208
209  /* This is conditionalized only because that is the way the front
210     ends used to do it.  Maybe this should be unconditional?  */
211  if (c_dialect_cxx ())
212    {
213      /* By default wrap lines at 80 characters.  Is getenv
214	 ("COLUMNS") preferable?  */
215      diagnostic_line_cutoff (global_dc) = 80;
216      /* By default, emit location information once for every
217	 diagnostic message.  */
218      diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
219    }
220
221  parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89,
222				ident_hash, &line_table);
223
224  cpp_opts = cpp_get_options (parse_in);
225  cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
226  cpp_opts->objc = c_dialect_objc ();
227
228  /* Reset to avoid warnings on internal definitions.  We set it just
229     before passing on command-line options to cpplib.  */
230  cpp_opts->warn_dollars = 0;
231
232  flag_exceptions = c_dialect_cxx ();
233  warn_pointer_arith = c_dialect_cxx ();
234  warn_write_strings = c_dialect_cxx();
235
236  deferred_opts = XNEWVEC (struct deferred_opt, argc);
237
238  result = lang_flags[c_language];
239
240  if (c_language == clk_c)
241    {
242      /* If preprocessing assembly language, accept any of the C-family
243	 front end options since the driver may pass them through.  */
244      for (i = 1; i < argc; i++)
245	if (! strcmp (argv[i], "-lang-asm"))
246	  {
247	    result |= CL_C | CL_ObjC | CL_CXX | CL_ObjCXX;
248	    break;
249	  }
250
251#ifdef CL_Fortran
252      for (i = 1; i < argc; i++)
253	if (! strcmp (argv[i], "-lang-fortran"))
254	{
255	    result |= CL_Fortran;
256	    break;
257	}
258#endif
259    }
260
261  return result;
262}
263
264/* Handle switch SCODE with argument ARG.  VALUE is true, unless no-
265   form of an -f or -W option was given.  Returns 0 if the switch was
266   invalid, a negative number to prevent language-independent
267   processing in toplev.c (a hack necessary for the short-term).  */
268int
269c_common_handle_option (size_t scode, const char *arg, int value)
270{
271  const struct cl_option *option = &cl_options[scode];
272  enum opt_code code = (enum opt_code) scode;
273  int result = 1;
274
275  /* Prevent resetting the language standard to a C dialect when the driver
276     has already determined that we're looking at assembler input.  */
277  bool preprocessing_asm_p = (cpp_get_options (parse_in)->lang == CLK_ASM);
278
279  switch (code)
280    {
281    default:
282      if (cl_options[code].flags & (CL_C | CL_CXX | CL_ObjC | CL_ObjCXX))
283	break;
284#ifdef CL_Fortran
285      if (lang_fortran && (cl_options[code].flags & (CL_Fortran)))
286	break;
287#endif
288      result = 0;
289      break;
290
291    case OPT__output_pch_:
292      pch_file = arg;
293      break;
294
295    case OPT_A:
296      defer_opt (code, arg);
297      break;
298
299    case OPT_C:
300      cpp_opts->discard_comments = 0;
301      break;
302
303    case OPT_CC:
304      cpp_opts->discard_comments = 0;
305      cpp_opts->discard_comments_in_macro_exp = 0;
306      break;
307
308    case OPT_D:
309      defer_opt (code, arg);
310      break;
311
312    case OPT_E:
313      flag_preprocess_only = 1;
314      break;
315
316    case OPT_H:
317      cpp_opts->print_include_names = 1;
318      break;
319
320    case OPT_F:
321      TARGET_OPTF (xstrdup (arg));
322      break;
323
324    case OPT_I:
325      if (strcmp (arg, "-"))
326	add_path (xstrdup (arg), BRACKET, 0, true);
327      else
328	{
329	  if (quote_chain_split)
330	    error ("-I- specified twice");
331	  quote_chain_split = true;
332	  split_quote_chain ();
333	  inform ("obsolete option -I- used, please use -iquote instead");
334	}
335      break;
336
337    case OPT_M:
338    case OPT_MM:
339      /* When doing dependencies with -M or -MM, suppress normal
340	 preprocessed output, but still do -dM etc. as software
341	 depends on this.  Preprocessed output does occur if -MD, -MMD
342	 or environment var dependency generation is used.  */
343      cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER);
344      flag_no_output = 1;
345      cpp_opts->inhibit_warnings = 1;
346      break;
347
348    case OPT_MD:
349    case OPT_MMD:
350      cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER);
351      deps_file = arg;
352      break;
353
354    case OPT_MF:
355      deps_seen = true;
356      deps_file = arg;
357      break;
358
359    case OPT_MG:
360      deps_seen = true;
361      cpp_opts->deps.missing_files = true;
362      break;
363
364    case OPT_MP:
365      deps_seen = true;
366      cpp_opts->deps.phony_targets = true;
367      break;
368
369    case OPT_MQ:
370    case OPT_MT:
371      deps_seen = true;
372      defer_opt (code, arg);
373      break;
374
375    case OPT_P:
376      flag_no_line_commands = 1;
377      break;
378
379    case OPT_fworking_directory:
380      flag_working_directory = value;
381      break;
382
383    case OPT_U:
384      defer_opt (code, arg);
385      break;
386
387    case OPT_Wall:
388      set_Wunused (value);
389      set_Wformat (value);
390      set_Wimplicit (value);
391      warn_char_subscripts = value;
392      warn_missing_braces = value;
393      warn_parentheses = value;
394      warn_return_type = value;
395      warn_sequence_point = value;	/* Was C only.  */
396      if (c_dialect_cxx ())
397	warn_sign_compare = value;
398      warn_switch = value;
399      warn_strict_aliasing = value;
400      warn_strict_overflow = value;
401      warn_address = value;
402
403      /* Only warn about unknown pragmas that are not in system
404	 headers.  */
405      warn_unknown_pragmas = value;
406
407      /* We save the value of warn_uninitialized, since if they put
408	 -Wuninitialized on the command line, we need to generate a
409	 warning about not using it without also specifying -O.  */
410      if (warn_uninitialized != 1)
411	warn_uninitialized = (value ? 2 : 0);
412
413      if (!c_dialect_cxx ())
414	/* We set this to 2 here, but 1 in -Wmain, so -ffreestanding
415	   can turn it off only if it's not explicit.  */
416	warn_main = value * 2;
417      else
418	{
419	  /* C++-specific warnings.  */
420	  warn_reorder = value;
421	  warn_nontemplate_friend = value;
422	}
423
424      cpp_opts->warn_trigraphs = value;
425      cpp_opts->warn_comments = value;
426      cpp_opts->warn_num_sign_change = value;
427      cpp_opts->warn_multichar = value;	/* Was C++ only.  */
428
429      if (warn_pointer_sign == -1)
430	warn_pointer_sign = 1;
431      break;
432
433    case OPT_Wcomment:
434    case OPT_Wcomments:
435      cpp_opts->warn_comments = value;
436      break;
437
438    case OPT_Wdeprecated:
439      cpp_opts->warn_deprecated = value;
440      break;
441
442    case OPT_Wendif_labels:
443      cpp_opts->warn_endif_labels = value;
444      break;
445
446    case OPT_Werror:
447      cpp_opts->warnings_are_errors = value;
448      global_dc->warning_as_error_requested = value;
449      break;
450
451    case OPT_Werror_implicit_function_declaration:
452      mesg_implicit_function_declaration = 2;
453      break;
454
455    case OPT_Wformat:
456      set_Wformat (value);
457      break;
458
459    case OPT_Wformat_:
460      set_Wformat (atoi (arg));
461      break;
462
463    case OPT_Wimplicit:
464      set_Wimplicit (value);
465      break;
466
467    case OPT_Wimport:
468      /* Silently ignore for now.  */
469      break;
470
471    case OPT_Winvalid_pch:
472      cpp_opts->warn_invalid_pch = value;
473      break;
474
475    case OPT_Wmain:
476      if (value)
477	warn_main = 1;
478      else
479	warn_main = -1;
480      break;
481
482    case OPT_Wmissing_include_dirs:
483      cpp_opts->warn_missing_include_dirs = value;
484      break;
485
486    case OPT_Wmultichar:
487      cpp_opts->warn_multichar = value;
488      break;
489
490    case OPT_Wnormalized_:
491      if (!value || (arg && strcasecmp (arg, "none") == 0))
492	cpp_opts->warn_normalize = normalized_none;
493      else if (!arg || strcasecmp (arg, "nfkc") == 0)
494	cpp_opts->warn_normalize = normalized_KC;
495      else if (strcasecmp (arg, "id") == 0)
496	cpp_opts->warn_normalize = normalized_identifier_C;
497      else if (strcasecmp (arg, "nfc") == 0)
498	cpp_opts->warn_normalize = normalized_C;
499      else
500	error ("argument %qs to %<-Wnormalized%> not recognized", arg);
501      break;
502
503    case OPT_Wreturn_type:
504      warn_return_type = value;
505      break;
506
507    case OPT_Wstrict_null_sentinel:
508      warn_strict_null_sentinel = value;
509      break;
510
511    case OPT_Wsystem_headers:
512      cpp_opts->warn_system_headers = value;
513      break;
514
515    case OPT_Wtraditional:
516      cpp_opts->warn_traditional = value;
517      break;
518
519    case OPT_Wtrigraphs:
520      cpp_opts->warn_trigraphs = value;
521      break;
522
523    case OPT_Wundef:
524      cpp_opts->warn_undef = value;
525      break;
526
527    case OPT_Wunknown_pragmas:
528      /* Set to greater than 1, so that even unknown pragmas in
529	 system headers will be warned about.  */
530      warn_unknown_pragmas = value * 2;
531      break;
532
533    case OPT_Wunused_macros:
534      warn_unused_macros = value;
535      break;
536
537    case OPT_Wvariadic_macros:
538      warn_variadic_macros = value;
539      break;
540
541    case OPT_Wwrite_strings:
542      warn_write_strings = value;
543      break;
544
545    case OPT_Weffc__:
546      warn_ecpp = value;
547      if (value)
548        warn_nonvdtor = true;
549      break;
550
551    case OPT_ansi:
552      if (!c_dialect_cxx ())
553	set_std_c89 (false, true);
554      else
555	set_std_cxx98 (true);
556      break;
557
558    case OPT_d:
559      handle_OPT_d (arg);
560      break;
561
562    case OPT_fcond_mismatch:
563      if (!c_dialect_cxx ())
564	{
565	  flag_cond_mismatch = value;
566	  break;
567	}
568      /* Fall through.  */
569
570    case OPT_fall_virtual:
571    case OPT_falt_external_templates:
572    case OPT_fenum_int_equiv:
573    case OPT_fexternal_templates:
574    case OPT_fguiding_decls:
575    case OPT_fhonor_std:
576    case OPT_fhuge_objects:
577    case OPT_flabels_ok:
578    case OPT_fname_mangling_version_:
579    case OPT_fnew_abi:
580    case OPT_fnonnull_objects:
581    case OPT_fsquangle:
582    case OPT_fstrict_prototype:
583    case OPT_fthis_is_variable:
584    case OPT_fvtable_thunks:
585    case OPT_fxref:
586    case OPT_fvtable_gc:
587      warning (0, "switch %qs is no longer supported", option->opt_text);
588      break;
589
590    case OPT_faccess_control:
591      flag_access_control = value;
592      break;
593
594    case OPT_fasm:
595      flag_no_asm = !value;
596      break;
597
598    case OPT_fbuiltin:
599      flag_no_builtin = !value;
600      break;
601
602    case OPT_fbuiltin_:
603      if (value)
604	result = 0;
605      else
606	disable_builtin_function (arg);
607      break;
608
609    case OPT_fdollars_in_identifiers:
610      cpp_opts->dollars_in_ident = value;
611      break;
612
613    case OPT_ffreestanding:
614      value = !value;
615      /* Fall through....  */
616    case OPT_fhosted:
617      flag_hosted = value;
618      flag_no_builtin = !value;
619      /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
620      if (!value && warn_main == 2)
621	warn_main = 0;
622      break;
623
624    case OPT_fshort_double:
625      flag_short_double = value;
626      break;
627
628    case OPT_fshort_enums:
629      flag_short_enums = value;
630      break;
631
632    case OPT_fshort_wchar:
633      flag_short_wchar = value;
634      break;
635
636    case OPT_fsigned_bitfields:
637      flag_signed_bitfields = value;
638      break;
639
640    case OPT_fsigned_char:
641      flag_signed_char = value;
642      break;
643
644    case OPT_funsigned_bitfields:
645      flag_signed_bitfields = !value;
646      break;
647
648    case OPT_funsigned_char:
649      flag_signed_char = !value;
650      break;
651
652    case OPT_fcheck_new:
653      flag_check_new = value;
654      break;
655
656    case OPT_fconserve_space:
657      flag_conserve_space = value;
658      break;
659
660    case OPT_fconstant_string_class_:
661      constant_string_class_name = arg;
662      break;
663
664    case OPT_fdefault_inline:
665      flag_default_inline = value;
666      break;
667
668    case OPT_felide_constructors:
669      flag_elide_constructors = value;
670      break;
671
672    case OPT_fenforce_eh_specs:
673      flag_enforce_eh_specs = value;
674      break;
675
676    case OPT_fextended_identifiers:
677      cpp_opts->extended_identifiers = value;
678      break;
679
680    case OPT_ffor_scope:
681      flag_new_for_scope = value;
682      break;
683
684    case OPT_fgnu_keywords:
685      flag_no_gnu_keywords = !value;
686      break;
687
688    case OPT_fgnu_runtime:
689      flag_next_runtime = !value;
690      break;
691
692    case OPT_fhandle_exceptions:
693      warning (0, "-fhandle-exceptions has been renamed -fexceptions (and is now on by default)");
694      flag_exceptions = value;
695      break;
696
697    case OPT_fimplement_inlines:
698      flag_implement_inlines = value;
699      break;
700
701    case OPT_fimplicit_inline_templates:
702      flag_implicit_inline_templates = value;
703      break;
704
705    case OPT_fimplicit_templates:
706      flag_implicit_templates = value;
707      break;
708
709    case OPT_fms_extensions:
710      flag_ms_extensions = value;
711      break;
712
713    case OPT_fnext_runtime:
714      flag_next_runtime = value;
715      break;
716
717    case OPT_fnil_receivers:
718      flag_nil_receivers = value;
719      break;
720
721    case OPT_fnonansi_builtins:
722      flag_no_nonansi_builtin = !value;
723      break;
724
725    case OPT_foperator_names:
726      cpp_opts->operator_names = value;
727      break;
728
729    case OPT_foptional_diags:
730      flag_optional_diags = value;
731      break;
732
733    case OPT_fpch_deps:
734      cpp_opts->restore_pch_deps = value;
735      break;
736
737    case OPT_fpch_preprocess:
738      flag_pch_preprocess = value;
739      break;
740
741    case OPT_fpermissive:
742      flag_permissive = value;
743      break;
744
745    case OPT_fpreprocessed:
746      cpp_opts->preprocessed = value;
747      break;
748
749    case OPT_freplace_objc_classes:
750      flag_replace_objc_classes = value;
751      break;
752
753    case OPT_frepo:
754      flag_use_repository = value;
755      if (value)
756	flag_implicit_templates = 0;
757      break;
758
759    case OPT_frtti:
760      flag_rtti = value;
761      break;
762
763    case OPT_fshow_column:
764      cpp_opts->show_column = value;
765      break;
766
767    case OPT_fstats:
768      flag_detailed_statistics = value;
769      break;
770
771    case OPT_ftabstop_:
772      /* It is documented that we silently ignore silly values.  */
773      if (value >= 1 && value <= 100)
774	cpp_opts->tabstop = value;
775      break;
776
777    case OPT_fexec_charset_:
778      cpp_opts->narrow_charset = arg;
779      break;
780
781    case OPT_fwide_exec_charset_:
782      cpp_opts->wide_charset = arg;
783      break;
784
785    case OPT_finput_charset_:
786      cpp_opts->input_charset = arg;
787      break;
788
789    case OPT_ftemplate_depth_:
790      max_tinst_depth = value;
791      break;
792
793    case OPT_fuse_cxa_atexit:
794      flag_use_cxa_atexit = value;
795      break;
796
797    case OPT_fuse_cxa_get_exception_ptr:
798      flag_use_cxa_get_exception_ptr = value;
799      break;
800
801    case OPT_fvisibility_inlines_hidden:
802      visibility_options.inlines_hidden = value;
803      break;
804
805    case OPT_fweak:
806      flag_weak = value;
807      break;
808
809    case OPT_fthreadsafe_statics:
810      flag_threadsafe_statics = value;
811      break;
812
813    case OPT_fzero_link:
814      flag_zero_link = value;
815      break;
816
817    case OPT_gen_decls:
818      flag_gen_declaration = 1;
819      break;
820
821    case OPT_femit_struct_debug_baseonly:
822      set_struct_debug_option ("base");
823      break;
824
825    case OPT_femit_struct_debug_reduced:
826      set_struct_debug_option ("dir:ord:sys,dir:gen:any,ind:base");
827      break;
828
829    case OPT_femit_struct_debug_detailed_:
830      set_struct_debug_option (arg);
831      break;
832
833    case OPT_idirafter:
834      add_path (xstrdup (arg), AFTER, 0, true);
835      break;
836
837    case OPT_imacros:
838    case OPT_include:
839      defer_opt (code, arg);
840      break;
841
842    case OPT_imultilib:
843      imultilib = arg;
844      break;
845
846    case OPT_iprefix:
847      iprefix = arg;
848      break;
849
850    case OPT_iquote:
851      add_path (xstrdup (arg), QUOTE, 0, true);
852      break;
853
854    case OPT_isysroot:
855      sysroot = arg;
856      break;
857
858    case OPT_isystem:
859      add_path (xstrdup (arg), SYSTEM, 0, true);
860      break;
861
862    case OPT_iwithprefix:
863      add_prefixed_path (arg, SYSTEM);
864      break;
865
866    case OPT_iwithprefixbefore:
867      add_prefixed_path (arg, BRACKET);
868      break;
869
870    case OPT_lang_asm:
871      cpp_set_lang (parse_in, CLK_ASM);
872      cpp_opts->dollars_in_ident = false;
873      break;
874
875    case OPT_lang_fortran:
876      lang_fortran = true;
877      break;
878
879    case OPT_lang_objc:
880      cpp_opts->objc = 1;
881      break;
882
883    case OPT_nostdinc:
884      std_inc = false;
885      break;
886
887    case OPT_nostdinc__:
888      std_cxx_inc = false;
889      break;
890
891    case OPT_o:
892      if (!out_fname)
893	out_fname = arg;
894      else
895	error ("output filename specified twice");
896      break;
897
898      /* We need to handle the -pedantic switches here, rather than in
899	 c_common_post_options, so that a subsequent -Wno-endif-labels
900	 is not overridden.  */
901    case OPT_pedantic_errors:
902      cpp_opts->pedantic_errors = 1;
903      /* Fall through.  */
904    case OPT_pedantic:
905      cpp_opts->pedantic = 1;
906      cpp_opts->warn_endif_labels = 1;
907      if (warn_pointer_sign == -1)
908	warn_pointer_sign = 1;
909      if (warn_overlength_strings == -1)
910	warn_overlength_strings = 1;
911      break;
912
913    case OPT_print_objc_runtime_info:
914      print_struct_values = 1;
915      break;
916
917    case OPT_print_pch_checksum:
918      c_common_print_pch_checksum (stdout);
919      exit_after_options = true;
920      break;
921
922    case OPT_remap:
923      cpp_opts->remap = 1;
924      break;
925
926    case OPT_std_c__98:
927    case OPT_std_gnu__98:
928      if (!preprocessing_asm_p)
929	set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
930      break;
931
932    case OPT_std_c89:
933    case OPT_std_iso9899_1990:
934    case OPT_std_iso9899_199409:
935      if (!preprocessing_asm_p)
936	set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
937      break;
938
939    case OPT_std_gnu89:
940      if (!preprocessing_asm_p)
941	set_std_c89 (false /* c94 */, false /* ISO */);
942      break;
943
944    case OPT_std_c99:
945    case OPT_std_c9x:
946    case OPT_std_iso9899_1999:
947    case OPT_std_iso9899_199x:
948      if (!preprocessing_asm_p)
949	set_std_c99 (true /* ISO */);
950      break;
951
952    case OPT_std_gnu99:
953    case OPT_std_gnu9x:
954      if (!preprocessing_asm_p)
955	set_std_c99 (false /* ISO */);
956      break;
957
958    case OPT_trigraphs:
959      cpp_opts->trigraphs = 1;
960      break;
961
962    case OPT_traditional_cpp:
963      cpp_opts->traditional = 1;
964      break;
965
966    case OPT_undef:
967      flag_undef = 1;
968      break;
969
970    case OPT_w:
971      cpp_opts->inhibit_warnings = 1;
972      break;
973
974    case OPT_v:
975      verbose = true;
976      break;
977    }
978
979  return result;
980}
981
982/* Post-switch processing.  */
983bool
984c_common_post_options (const char **pfilename)
985{
986  struct cpp_callbacks *cb;
987
988  /* Canonicalize the input and output filenames.  */
989  if (in_fnames == NULL)
990    {
991      in_fnames = XNEWVEC (const char *, 1);
992      in_fnames[0] = "";
993    }
994  else if (strcmp (in_fnames[0], "-") == 0)
995    in_fnames[0] = "";
996
997  if (out_fname == NULL || !strcmp (out_fname, "-"))
998    out_fname = "";
999
1000  if (cpp_opts->deps.style == DEPS_NONE)
1001    check_deps_environment_vars ();
1002
1003  handle_deferred_opts ();
1004
1005  sanitize_cpp_opts ();
1006
1007  register_include_chains (parse_in, sysroot, iprefix, imultilib,
1008			   std_inc, std_cxx_inc && c_dialect_cxx (), verbose);
1009
1010#ifdef C_COMMON_OVERRIDE_OPTIONS
1011  /* Some machines may reject certain combinations of C
1012     language-specific options.  */
1013  C_COMMON_OVERRIDE_OPTIONS;
1014#endif
1015
1016  flag_inline_trees = 1;
1017
1018  /* Use tree inlining.  */
1019  if (!flag_no_inline)
1020    flag_no_inline = 1;
1021  if (flag_inline_functions)
1022    flag_inline_trees = 2;
1023
1024  /* By default we use C99 inline semantics in GNU99 or C99 mode.  C99
1025     inline semantics are not supported in GNU89 or C89 mode.  */
1026  if (flag_gnu89_inline == -1)
1027    flag_gnu89_inline = !flag_isoc99;
1028  else if (!flag_gnu89_inline && !flag_isoc99)
1029    error ("-fno-gnu89-inline is only supported in GNU99 or C99 mode");
1030
1031  /* If we are given more than one input file, we must use
1032     unit-at-a-time mode.  */
1033  if (num_in_fnames > 1)
1034    flag_unit_at_a_time = 1;
1035
1036  /* Default to ObjC sjlj exception handling if NeXT runtime.  */
1037  if (flag_objc_sjlj_exceptions < 0)
1038    flag_objc_sjlj_exceptions = flag_next_runtime;
1039  if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
1040    flag_exceptions = 1;
1041
1042  /* -Wextra implies -Wsign-compare, -Wmissing-field-initializers and
1043     -Woverride-init, but not if explicitly overridden.  */
1044  if (warn_sign_compare == -1)
1045    warn_sign_compare = extra_warnings;
1046  if (warn_missing_field_initializers == -1)
1047    warn_missing_field_initializers = extra_warnings;
1048  if (warn_override_init == -1)
1049    warn_override_init = extra_warnings;
1050
1051  /* -Wpointer_sign is disabled by default, but it is enabled if any
1052     of -Wall or -pedantic are given.  */
1053  if (warn_pointer_sign == -1)
1054    warn_pointer_sign = 0;
1055
1056  /* -Woverlength-strings is off by default, but is enabled by -pedantic.
1057     It is never enabled in C++, as the minimum limit is not normative
1058     in that standard.  */
1059  if (warn_overlength_strings == -1 || c_dialect_cxx ())
1060    warn_overlength_strings = 0;
1061
1062  /* Special format checking options don't work without -Wformat; warn if
1063     they are used.  */
1064  if (!warn_format)
1065    {
1066      warning (OPT_Wformat_y2k,
1067	       "-Wformat-y2k ignored without -Wformat");
1068      warning (OPT_Wformat_extra_args,
1069	       "-Wformat-extra-args ignored without -Wformat");
1070      warning (OPT_Wformat_zero_length,
1071	       "-Wformat-zero-length ignored without -Wformat");
1072      warning (OPT_Wformat_nonliteral,
1073	       "-Wformat-nonliteral ignored without -Wformat");
1074      warning (OPT_Wformat_security,
1075	       "-Wformat-security ignored without -Wformat");
1076    }
1077
1078  /* C99 requires special handling of complex multiplication and division;
1079     -ffast-math and -fcx-limited-range are handled in process_options.  */
1080  if (flag_isoc99)
1081    flag_complex_method = 2;
1082
1083  if (flag_preprocess_only)
1084    {
1085      /* Open the output now.  We must do so even if flag_no_output is
1086	 on, because there may be other output than from the actual
1087	 preprocessing (e.g. from -dM).  */
1088      if (out_fname[0] == '\0')
1089	out_stream = stdout;
1090      else
1091	out_stream = fopen (out_fname, "w");
1092
1093      if (out_stream == NULL)
1094	{
1095	  fatal_error ("opening output file %s: %m", out_fname);
1096	  return false;
1097	}
1098
1099      if (num_in_fnames > 1)
1100	error ("too many filenames given.  Type %s --help for usage",
1101	       progname);
1102
1103      init_pp_output (out_stream);
1104    }
1105  else
1106    {
1107      init_c_lex ();
1108
1109      /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
1110      input_location = UNKNOWN_LOCATION;
1111    }
1112
1113  cb = cpp_get_callbacks (parse_in);
1114  cb->file_change = cb_file_change;
1115  cb->dir_change = cb_dir_change;
1116  cpp_post_options (parse_in);
1117
1118  input_location = UNKNOWN_LOCATION;
1119
1120  /* If an error has occurred in cpplib, note it so we fail
1121     immediately.  */
1122  errorcount += cpp_errors (parse_in);
1123
1124  *pfilename = this_input_filename
1125    = cpp_read_main_file (parse_in, in_fnames[0]);
1126  /* Don't do any compilation or preprocessing if there is no input file.  */
1127  if (this_input_filename == NULL)
1128    {
1129      errorcount++;
1130      return false;
1131    }
1132
1133  if (flag_working_directory
1134      && flag_preprocess_only && !flag_no_line_commands)
1135    pp_dir_change (parse_in, get_src_pwd ());
1136
1137  return flag_preprocess_only;
1138}
1139
1140/* Front end initialization common to C, ObjC and C++.  */
1141bool
1142c_common_init (void)
1143{
1144  /* Set up preprocessor arithmetic.  Must be done after call to
1145     c_common_nodes_and_builtins for type nodes to be good.  */
1146  cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1147  cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1148  cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1149  cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1150  cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1151  cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1152
1153  /* This can't happen until after wchar_precision and bytes_big_endian
1154     are known.  */
1155  cpp_init_iconv (parse_in);
1156
1157  if (version_flag)
1158    c_common_print_pch_checksum (stderr);
1159
1160  if (flag_preprocess_only)
1161    {
1162      finish_options ();
1163      preprocess_file (parse_in);
1164      return false;
1165    }
1166
1167  /* Has to wait until now so that cpplib has its hash table.  */
1168  init_pragma ();
1169
1170  return true;
1171}
1172
1173/* Initialize the integrated preprocessor after debug output has been
1174   initialized; loop over each input file.  */
1175void
1176c_common_parse_file (int set_yydebug)
1177{
1178  unsigned int i;
1179
1180  /* Enable parser debugging, if requested and we can.  If requested
1181     and we can't, notify the user.  */
1182#if YYDEBUG != 0
1183  yydebug = set_yydebug;
1184#else
1185  if (set_yydebug)
1186    warning (0, "YYDEBUG was not defined at build time, -dy ignored");
1187#endif
1188
1189  i = 0;
1190  for (;;)
1191    {
1192      /* Start the main input file, if the debug writer wants it. */
1193      if (debug_hooks->start_end_main_source_file)
1194	(*debug_hooks->start_source_file) (0, this_input_filename);
1195      finish_options ();
1196      pch_init ();
1197      push_file_scope ();
1198      c_parse_file ();
1199      finish_file ();
1200      pop_file_scope ();
1201      /* And end the main input file, if the debug writer wants it  */
1202      if (debug_hooks->start_end_main_source_file)
1203	(*debug_hooks->end_source_file) (0);
1204      if (++i >= num_in_fnames)
1205	break;
1206      cpp_undef_all (parse_in);
1207      this_input_filename
1208	= cpp_read_main_file (parse_in, in_fnames[i]);
1209      /* If an input file is missing, abandon further compilation.
1210	 cpplib has issued a diagnostic.  */
1211      if (!this_input_filename)
1212	break;
1213    }
1214}
1215
1216/* Common finish hook for the C, ObjC and C++ front ends.  */
1217void
1218c_common_finish (void)
1219{
1220  FILE *deps_stream = NULL;
1221
1222  if (cpp_opts->deps.style != DEPS_NONE)
1223    {
1224      /* If -M or -MM was seen without -MF, default output to the
1225	 output stream.  */
1226      if (!deps_file)
1227	deps_stream = out_stream;
1228      else
1229	{
1230	  deps_stream = fopen (deps_file, deps_append ? "a": "w");
1231	  if (!deps_stream)
1232	    fatal_error ("opening dependency file %s: %m", deps_file);
1233	}
1234    }
1235
1236  /* For performance, avoid tearing down cpplib's internal structures
1237     with cpp_destroy ().  */
1238  errorcount += cpp_finish (parse_in, deps_stream);
1239
1240  if (deps_stream && deps_stream != out_stream
1241      && (ferror (deps_stream) || fclose (deps_stream)))
1242    fatal_error ("closing dependency file %s: %m", deps_file);
1243
1244  if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1245    fatal_error ("when writing output to %s: %m", out_fname);
1246}
1247
1248/* Either of two environment variables can specify output of
1249   dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1250   DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1251   and DEPS_TARGET is the target to mention in the deps.  They also
1252   result in dependency information being appended to the output file
1253   rather than overwriting it, and like Sun's compiler
1254   SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
1255static void
1256check_deps_environment_vars (void)
1257{
1258  char *spec;
1259
1260  GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1261  if (spec)
1262    cpp_opts->deps.style = DEPS_USER;
1263  else
1264    {
1265      GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1266      if (spec)
1267	{
1268	  cpp_opts->deps.style = DEPS_SYSTEM;
1269	  cpp_opts->deps.ignore_main_file = true;
1270	}
1271    }
1272
1273  if (spec)
1274    {
1275      /* Find the space before the DEPS_TARGET, if there is one.  */
1276      char *s = strchr (spec, ' ');
1277      if (s)
1278	{
1279	  /* Let the caller perform MAKE quoting.  */
1280	  defer_opt (OPT_MT, s + 1);
1281	  *s = '\0';
1282	}
1283
1284      /* Command line -MF overrides environment variables and default.  */
1285      if (!deps_file)
1286	deps_file = spec;
1287
1288      deps_append = 1;
1289      deps_seen = true;
1290    }
1291}
1292
1293/* Handle deferred command line switches.  */
1294static void
1295handle_deferred_opts (void)
1296{
1297  size_t i;
1298  struct deps *deps;
1299
1300  /* Avoid allocating the deps buffer if we don't need it.
1301     (This flag may be true without there having been -MT or -MQ
1302     options, but we'll still need the deps buffer.)  */
1303  if (!deps_seen)
1304    return;
1305
1306  deps = cpp_get_deps (parse_in);
1307
1308  for (i = 0; i < deferred_count; i++)
1309    {
1310      struct deferred_opt *opt = &deferred_opts[i];
1311
1312      if (opt->code == OPT_MT || opt->code == OPT_MQ)
1313	deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1314    }
1315}
1316
1317/* These settings are appropriate for GCC, but not necessarily so for
1318   cpplib as a library.  */
1319static void
1320sanitize_cpp_opts (void)
1321{
1322  /* If we don't know what style of dependencies to output, complain
1323     if any other dependency switches have been given.  */
1324  if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1325    error ("to generate dependencies you must specify either -M or -MM");
1326
1327  /* -dM and dependencies suppress normal output; do it here so that
1328     the last -d[MDN] switch overrides earlier ones.  */
1329  if (flag_dump_macros == 'M')
1330    flag_no_output = 1;
1331
1332  /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
1333     -dM since at least glibc relies on -M -dM to work.  */
1334  /* Also, flag_no_output implies flag_no_line_commands, always.  */
1335  if (flag_no_output)
1336    {
1337      if (flag_dump_macros != 'M')
1338	flag_dump_macros = 0;
1339      flag_dump_includes = 0;
1340      flag_no_line_commands = 1;
1341    }
1342
1343  cpp_opts->unsigned_char = !flag_signed_char;
1344  cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1345
1346  /* We want -Wno-long-long to override -pedantic -std=non-c99
1347     and/or -Wtraditional, whatever the ordering.  */
1348  cpp_opts->warn_long_long
1349    = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
1350
1351  /* Similarly with -Wno-variadic-macros.  No check for c99 here, since
1352     this also turns off warnings about GCCs extension.  */
1353  cpp_opts->warn_variadic_macros
1354    = warn_variadic_macros && (pedantic || warn_traditional);
1355
1356  /* If we're generating preprocessor output, emit current directory
1357     if explicitly requested or if debugging information is enabled.
1358     ??? Maybe we should only do it for debugging formats that
1359     actually output the current directory?  */
1360  if (flag_working_directory == -1)
1361    flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1362}
1363
1364/* Add include path with a prefix at the front of its name.  */
1365static void
1366add_prefixed_path (const char *suffix, size_t chain)
1367{
1368  char *path;
1369  const char *prefix;
1370  size_t prefix_len, suffix_len;
1371
1372  suffix_len = strlen (suffix);
1373  prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1374  prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1375
1376  path = (char *) xmalloc (prefix_len + suffix_len + 1);
1377  memcpy (path, prefix, prefix_len);
1378  memcpy (path + prefix_len, suffix, suffix_len);
1379  path[prefix_len + suffix_len] = '\0';
1380
1381  add_path (path, chain, 0, false);
1382}
1383
1384/* Handle -D, -U, -A, -imacros, and the first -include.  */
1385static void
1386finish_options (void)
1387{
1388  if (!cpp_opts->preprocessed)
1389    {
1390      size_t i;
1391
1392      cb_file_change (parse_in,
1393		      linemap_add (&line_table, LC_RENAME, 0,
1394				   _("<built-in>"), 0));
1395
1396      cpp_init_builtins (parse_in, flag_hosted);
1397      c_cpp_builtins (parse_in);
1398
1399      /* We're about to send user input to cpplib, so make it warn for
1400	 things that we previously (when we sent it internal definitions)
1401	 told it to not warn.
1402
1403	 C99 permits implementation-defined characters in identifiers.
1404	 The documented meaning of -std= is to turn off extensions that
1405	 conflict with the specified standard, and since a strictly
1406	 conforming program cannot contain a '$', we do not condition
1407	 their acceptance on the -std= setting.  */
1408      cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
1409
1410      cb_file_change (parse_in,
1411		      linemap_add (&line_table, LC_RENAME, 0,
1412				   _("<command-line>"), 0));
1413
1414      for (i = 0; i < deferred_count; i++)
1415	{
1416	  struct deferred_opt *opt = &deferred_opts[i];
1417
1418	  if (opt->code == OPT_D)
1419	    cpp_define (parse_in, opt->arg);
1420	  else if (opt->code == OPT_U)
1421	    cpp_undef (parse_in, opt->arg);
1422	  else if (opt->code == OPT_A)
1423	    {
1424	      if (opt->arg[0] == '-')
1425		cpp_unassert (parse_in, opt->arg + 1);
1426	      else
1427		cpp_assert (parse_in, opt->arg);
1428	    }
1429	}
1430
1431      /* Handle -imacros after -D and -U.  */
1432      for (i = 0; i < deferred_count; i++)
1433	{
1434	  struct deferred_opt *opt = &deferred_opts[i];
1435
1436	  if (opt->code == OPT_imacros
1437	      && cpp_push_include (parse_in, opt->arg))
1438	    {
1439	      /* Disable push_command_line_include callback for now.  */
1440	      include_cursor = deferred_count + 1;
1441	      cpp_scan_nooutput (parse_in);
1442	    }
1443	}
1444    }
1445
1446  include_cursor = 0;
1447  push_command_line_include ();
1448}
1449
1450/* Give CPP the next file given by -include, if any.  */
1451static void
1452push_command_line_include (void)
1453{
1454  while (include_cursor < deferred_count)
1455    {
1456      struct deferred_opt *opt = &deferred_opts[include_cursor++];
1457
1458      if (!cpp_opts->preprocessed && opt->code == OPT_include
1459	  && cpp_push_include (parse_in, opt->arg))
1460	return;
1461    }
1462
1463  if (include_cursor == deferred_count)
1464    {
1465      include_cursor++;
1466      /* -Wunused-macros should only warn about macros defined hereafter.  */
1467      cpp_opts->warn_unused_macros = warn_unused_macros;
1468      /* Restore the line map from <command line>.  */
1469      if (!cpp_opts->preprocessed)
1470	cpp_change_file (parse_in, LC_RENAME, this_input_filename);
1471
1472      /* Set this here so the client can change the option if it wishes,
1473	 and after stacking the main file so we don't trace the main file.  */
1474      line_table.trace_includes = cpp_opts->print_include_names;
1475    }
1476}
1477
1478/* File change callback.  Has to handle -include files.  */
1479static void
1480cb_file_change (cpp_reader * ARG_UNUSED (pfile),
1481		const struct line_map *new_map)
1482{
1483  if (flag_preprocess_only)
1484    pp_file_change (new_map);
1485  else
1486    fe_file_change (new_map);
1487
1488  if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1489    push_command_line_include ();
1490}
1491
1492void
1493cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
1494{
1495  if (!set_src_pwd (dir))
1496    warning (0, "too late for # directive to set debug directory");
1497}
1498
1499/* Set the C 89 standard (with 1994 amendments if C94, without GNU
1500   extensions if ISO).  There is no concept of gnu94.  */
1501static void
1502set_std_c89 (int c94, int iso)
1503{
1504  cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1505  flag_iso = iso;
1506  flag_no_asm = iso;
1507  flag_no_gnu_keywords = iso;
1508  flag_no_nonansi_builtin = iso;
1509  flag_isoc94 = c94;
1510  flag_isoc99 = 0;
1511}
1512
1513/* Set the C 99 standard (without GNU extensions if ISO).  */
1514static void
1515set_std_c99 (int iso)
1516{
1517  cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1518  flag_no_asm = iso;
1519  flag_no_nonansi_builtin = iso;
1520  flag_iso = iso;
1521  flag_isoc99 = 1;
1522  flag_isoc94 = 1;
1523}
1524
1525/* Set the C++ 98 standard (without GNU extensions if ISO).  */
1526static void
1527set_std_cxx98 (int iso)
1528{
1529  cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1530  flag_no_gnu_keywords = iso;
1531  flag_no_nonansi_builtin = iso;
1532  flag_iso = iso;
1533}
1534
1535/* Handle setting implicit to ON.  */
1536static void
1537set_Wimplicit (int on)
1538{
1539  warn_implicit = on;
1540  warn_implicit_int = on;
1541  if (on)
1542    {
1543      if (mesg_implicit_function_declaration != 2)
1544	mesg_implicit_function_declaration = 1;
1545    }
1546  else
1547    mesg_implicit_function_declaration = 0;
1548}
1549
1550/* Args to -d specify what to dump.  Silently ignore
1551   unrecognized options; they may be aimed at toplev.c.  */
1552static void
1553handle_OPT_d (const char *arg)
1554{
1555  char c;
1556
1557  while ((c = *arg++) != '\0')
1558    switch (c)
1559      {
1560      case 'M':			/* Dump macros only.  */
1561      case 'N':			/* Dump names.  */
1562      case 'D':			/* Dump definitions.  */
1563	flag_dump_macros = c;
1564	break;
1565
1566      case 'I':
1567	flag_dump_includes = 1;
1568	break;
1569      }
1570}
1571