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