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