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