Line data Source code
1 : /* C/ObjC/C++ command line option handling.
2 : Copyright (C) 2002-2026 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 : #define INCLUDE_VECTOR
22 : #include "config.h"
23 : #include "system.h"
24 : #include "coretypes.h"
25 : #include "tm.h"
26 : #include "target.h"
27 : #include "c-target.h"
28 : #include "c-common.h"
29 : #include "memmodel.h"
30 : #include "tm_p.h" /* For C_COMMON_OVERRIDE_OPTIONS. */
31 : #include "diagnostic.h"
32 : #include "c-pragma.h"
33 : #include "flags.h"
34 : #include "toplev.h"
35 : #include "langhooks.h"
36 : #include "diagnostics/macro-unwinding.h" /* for virt_loc_aware_diagnostic_finalizer */
37 : #include "intl.h"
38 : #include "cppdefault.h"
39 : #include "incpath.h"
40 : #include "debug.h" /* For debug_hooks. */
41 : #include "opts.h"
42 : #include "plugin.h" /* For PLUGIN_INCLUDE_FILE event. */
43 : #include "mkdeps.h"
44 : #include "dumpfile.h"
45 : #include "file-prefix-map.h" /* add_*_prefix_map() */
46 : #include "context.h"
47 : #include "diagnostics/text-sink.h"
48 :
49 : #ifndef DOLLARS_IN_IDENTIFIERS
50 : # define DOLLARS_IN_IDENTIFIERS true
51 : #endif
52 :
53 : #ifndef TARGET_SYSTEM_ROOT
54 : # define TARGET_SYSTEM_ROOT NULL
55 : #endif
56 :
57 : #ifndef TARGET_OPTF
58 : #define TARGET_OPTF(ARG)
59 : #endif
60 :
61 : /* CPP's options. */
62 : cpp_options *cpp_opts;
63 :
64 : /* Input filename. */
65 : static const char *this_input_filename;
66 :
67 : /* Filename and stream for preprocessed output. */
68 : static const char *out_fname;
69 : static FILE *out_stream;
70 :
71 : /* Append dependencies to deps_file. */
72 : static bool deps_append;
73 :
74 : /* If dependency switches (-MF etc.) have been given. */
75 : static bool deps_seen;
76 :
77 : /* If -v seen. */
78 : static bool verbose;
79 :
80 : /* Dependency output file. */
81 : static const char *deps_file;
82 :
83 : /* Structured dependency output file. */
84 : static const char *fdeps_file;
85 :
86 : /* The prefix given by -iprefix, if any. */
87 : static const char *iprefix;
88 :
89 : /* The multilib directory given by -imultilib, if any. */
90 : static const char *imultilib;
91 :
92 : /* The system root, if any. Overridden by -isysroot. */
93 : static const char *sysroot = TARGET_SYSTEM_ROOT;
94 :
95 : /* Zero disables all standard directories for headers. */
96 : static bool std_inc = true;
97 :
98 : /* Zero disables the C++-specific standard directories for headers. */
99 : static bool std_cxx_inc = true;
100 :
101 : /* If the quote chain has been split by -I-. */
102 : static bool quote_chain_split;
103 :
104 : /* Number of deferred options. */
105 : static size_t deferred_count;
106 :
107 : /* Number of deferred options scanned for -include. */
108 : static size_t include_cursor;
109 :
110 : /* Whether any standard preincluded header has been preincluded. */
111 : static bool done_preinclude;
112 :
113 : static void handle_OPT_d (const char *);
114 : static void set_std_cxx98 (int);
115 : static void set_std_cxx11 (int);
116 : static void set_std_cxx14 (int);
117 : static void set_std_cxx17 (int);
118 : static void set_std_cxx20 (int);
119 : static void set_std_cxx23 (int);
120 : static void set_std_cxx26 (int);
121 : static void set_std_c89 (int, int);
122 : static void set_std_c99 (int);
123 : static void set_std_c11 (int);
124 : static void set_std_c17 (int);
125 : static void set_std_c23 (int);
126 : static void set_std_c2y (int);
127 : static void check_deps_environment_vars (void);
128 : static void handle_deferred_opts (void);
129 : static void sanitize_cpp_opts (void);
130 : static void add_prefixed_path (const char *, incpath_kind);
131 : static void push_command_line_include (void);
132 : static void cb_file_change (cpp_reader *, const line_map_ordinary *);
133 : static void cb_dir_change (cpp_reader *, const char *);
134 : static void c_finish_options (void);
135 :
136 : #ifndef STDC_0_IN_SYSTEM_HEADERS
137 : #define STDC_0_IN_SYSTEM_HEADERS 0
138 : #endif
139 :
140 : /* Holds switches parsed by c_common_handle_option (), but whose
141 : handling is deferred to c_common_post_options (). */
142 : static void defer_opt (enum opt_code, const char *);
143 : static struct deferred_opt
144 : {
145 : enum opt_code code;
146 : const char *arg;
147 : } *deferred_opts;
148 :
149 :
150 : extern const unsigned int
151 : c_family_lang_mask = (CL_C | CL_CXX | CL_ObjC | CL_ObjCXX);
152 :
153 : /* Defer option CODE with argument ARG. */
154 : static void
155 179042 : defer_opt (enum opt_code code, const char *arg)
156 : {
157 179042 : deferred_opts[deferred_count].code = code;
158 179042 : deferred_opts[deferred_count].arg = arg;
159 179042 : deferred_count++;
160 179042 : }
161 :
162 : /* Return language mask for option parsing. */
163 : unsigned int
164 6395136 : c_common_option_lang_mask (void)
165 : {
166 6395136 : static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX};
167 :
168 6395136 : return lang_flags[c_language];
169 : }
170 :
171 : /* Diagnostic finalizer for C/C++/Objective-C/Objective-C++. */
172 : static void
173 314631 : c_diagnostic_text_finalizer (diagnostics::text_sink &text_output,
174 : const diagnostics::diagnostic_info *diagnostic,
175 : enum diagnostics::kind)
176 : {
177 314631 : pretty_printer *const pp = text_output.get_printer ();
178 314631 : char *saved_prefix = pp_take_prefix (pp);
179 314631 : pp_set_prefix (pp, text_output.build_indent_prefix (false));
180 314631 : pp_newline (pp);
181 314631 : diagnostic_show_locus (&text_output.get_context (),
182 314631 : text_output.get_source_printing_options (),
183 314631 : diagnostic->m_richloc, diagnostic->m_kind, pp);
184 : /* By default print macro expansion contexts in the diagnostic
185 : finalizer -- for tokens resulting from macro expansion. */
186 314631 : diagnostics::virt_loc_aware_text_finalizer (text_output, diagnostic);
187 314631 : pp_set_prefix (pp, saved_prefix);
188 314631 : pp_flush (pp);
189 314631 : }
190 :
191 : /* Common default settings for diagnostics. */
192 : void
193 208440 : c_common_diagnostics_set_defaults (diagnostics::context *context)
194 : {
195 208440 : diagnostics::text_finalizer (context) = c_diagnostic_text_finalizer;
196 208440 : context->set_permissive_option (OPT_fpermissive);
197 208440 : }
198 :
199 : /* Input charset configuration for diagnostics. */
200 : static const char *
201 62401 : c_common_input_charset_cb (const char * /*filename*/)
202 : {
203 62401 : const char *cs = cpp_opts->input_charset;
204 62401 : return cpp_input_conversion_is_trivial (cs) ? nullptr : cs;
205 : }
206 :
207 : /* Whether options from all C-family languages should be accepted
208 : quietly. */
209 : static bool accept_all_c_family_options = false;
210 :
211 : /* Return whether to complain about a wrong-language option. */
212 : bool
213 293 : c_common_complain_wrong_lang_p (const struct cl_option *option)
214 : {
215 293 : if (accept_all_c_family_options
216 6 : && (option->flags & c_family_lang_mask))
217 6 : return false;
218 :
219 : return true;
220 : }
221 :
222 : /* Initialize options structure OPTS. */
223 : void
224 47960298 : c_common_init_options_struct (struct gcc_options *opts)
225 : {
226 47960298 : opts->x_flag_exceptions = c_dialect_cxx ();
227 47960298 : opts->x_warn_pointer_arith = c_dialect_cxx ();
228 47960298 : opts->x_warn_write_strings = c_dialect_cxx ();
229 47960298 : opts->x_flag_warn_unused_result = true;
230 :
231 : /* By default, C99-like requirements for complex multiply and divide. */
232 47960298 : opts->x_flag_complex_method = 2;
233 47960298 : }
234 :
235 : /* Common initialization before calling option handlers. */
236 : void
237 208440 : c_common_init_options (unsigned int decoded_options_count,
238 : struct cl_decoded_option *decoded_options)
239 : {
240 208440 : unsigned int i;
241 208440 : struct cpp_callbacks *cb;
242 :
243 208440 : g_string_concat_db
244 208440 : = new (ggc_alloc <string_concat_db> ()) string_concat_db ();
245 :
246 318761 : parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX : CLK_GNUC89,
247 : ident_hash, line_table, ident_hash_extra);
248 208440 : cb = cpp_get_callbacks (parse_in);
249 208440 : cb->diagnostic = c_cpp_diagnostic;
250 :
251 208440 : cpp_opts = cpp_get_options (parse_in);
252 208440 : cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
253 208440 : cpp_opts->objc = c_dialect_objc ();
254 208440 : cpp_opts->deps.modules = true;
255 :
256 : /* Reset to avoid warnings on internal definitions. We set it just
257 : before passing on command-line options to cpplib. */
258 208440 : cpp_opts->warn_dollars = 0;
259 :
260 208440 : deferred_opts = XNEWVEC (struct deferred_opt, decoded_options_count);
261 :
262 208440 : if (c_language == clk_c)
263 : {
264 : /* The default for C is gnu23. */
265 110321 : set_std_c23 (false /* ISO */);
266 :
267 : /* If preprocessing assembly language, accept any of the C-family
268 : front end options since the driver may pass them through. */
269 2821643 : for (i = 1; i < decoded_options_count; i++)
270 2601980 : if (decoded_options[i].opt_index == OPT_lang_asm)
271 : {
272 979 : accept_all_c_family_options = true;
273 979 : break;
274 : }
275 : }
276 :
277 : /* Set C++ standard to C++20 if not specified on the command line. */
278 208440 : if (c_dialect_cxx ())
279 98119 : set_std_cxx20 (/*ISO*/false);
280 :
281 208440 : global_dc->get_source_printing_options ().colorize_source_p = true;
282 208440 : }
283 :
284 : /* Handle switch SCODE with argument ARG. VALUE is true, unless no-
285 : form of an -f or -W option was given. Returns false if the switch was
286 : invalid, true if valid. Use HANDLERS in recursive handle_option calls. */
287 : bool
288 3338485 : c_common_handle_option (size_t scode, const char *arg, HOST_WIDE_INT value,
289 : int kind, location_t loc,
290 : const struct cl_option_handlers *handlers)
291 : {
292 3338485 : const struct cl_option *option = &cl_options[scode];
293 3338485 : enum opt_code code = (enum opt_code) scode;
294 3338485 : bool result = true;
295 :
296 : /* Prevent resetting the language standard to a C dialect when the driver
297 : has already determined that we're looking at assembler input. */
298 3338485 : bool preprocessing_asm_p = (cpp_get_options (parse_in)->lang == CLK_ASM);
299 :
300 3338485 : switch (code)
301 : {
302 1450900 : default:
303 1450900 : if (cl_options[code].flags & c_family_lang_mask)
304 : {
305 1450900 : if ((option->flags & CL_TARGET)
306 1450900 : && ! targetcm.handle_c_option (scode, arg, value))
307 : result = false;
308 : break;
309 : }
310 : result = false;
311 : break;
312 :
313 440 : case OPT__output_pch:
314 440 : pch_file = arg;
315 440 : break;
316 :
317 10 : case OPT_A:
318 10 : defer_opt (code, arg);
319 10 : break;
320 :
321 13 : case OPT_C:
322 13 : cpp_opts->discard_comments = 0;
323 13 : break;
324 :
325 11 : case OPT_CC:
326 11 : cpp_opts->discard_comments = 0;
327 11 : cpp_opts->discard_comments_in_macro_exp = 0;
328 11 : break;
329 :
330 163701 : case OPT_D:
331 163701 : defer_opt (code, arg);
332 163701 : break;
333 :
334 25 : case OPT_H:
335 25 : cpp_opts->print_include_names = 1;
336 25 : break;
337 :
338 : case OPT_F:
339 : TARGET_OPTF (xstrdup (arg));
340 : break;
341 :
342 556374 : case OPT_I:
343 556374 : if (strcmp (arg, "-"))
344 556374 : add_path (xstrdup (arg), INC_BRACKET, 0, true);
345 : else
346 : {
347 0 : if (quote_chain_split)
348 0 : error ("%<-I-%> specified twice");
349 0 : quote_chain_split = true;
350 0 : split_quote_chain ();
351 0 : inform (input_location, "obsolete option %<-I-%> used, "
352 : "please use %<-iquote%> instead");
353 : }
354 : break;
355 :
356 31 : case OPT_M:
357 31 : case OPT_MM:
358 : /* When doing dependencies with -M or -MM, suppress normal
359 : preprocessed output, but still do -dM etc. as software
360 : depends on this. Preprocessed output does occur if -MD, -MMD
361 : or environment var dependency generation is used. */
362 31 : cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM : DEPS_USER);
363 31 : flag_no_output = 1;
364 31 : break;
365 :
366 5892 : case OPT_MD:
367 5892 : case OPT_MMD:
368 5892 : cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM : DEPS_USER);
369 5892 : cpp_opts->deps.need_preprocessor_output = true;
370 5892 : deps_file = arg;
371 5892 : break;
372 :
373 51 : case OPT_fdeps_format_:
374 : /* https://wg21.link/p1689r5 */
375 51 : if (!strcmp (arg, "p1689r5"))
376 48 : cpp_opts->deps.fdeps_format = FDEPS_FMT_P1689R5;
377 : else
378 3 : error ("%<-fdeps-format=%> unknown format %qs", arg);
379 : break;
380 :
381 63 : case OPT_fdeps_file_:
382 63 : deps_seen = true;
383 63 : fdeps_file = arg;
384 63 : break;
385 :
386 63 : case OPT_fdeps_target_:
387 63 : deps_seen = true;
388 63 : defer_opt (code, arg);
389 63 : break;
390 :
391 5839 : case OPT_MF:
392 5839 : deps_seen = true;
393 5839 : deps_file = arg;
394 5839 : break;
395 :
396 6 : case OPT_MG:
397 6 : deps_seen = true;
398 6 : cpp_opts->deps.missing_files = true;
399 6 : break;
400 :
401 5821 : case OPT_MP:
402 5821 : deps_seen = true;
403 5821 : cpp_opts->deps.phony_targets = true;
404 5821 : break;
405 :
406 0 : case OPT_Mmodules:
407 : /* Do not set deps_seen, so the user can unconditionally turn
408 : this on or off. */
409 0 : cpp_opts->deps.modules = true;
410 0 : break;
411 :
412 3 : case OPT_Mno_modules:
413 : /* Do not set deps_seen, so the user can unconditionally turn
414 : this on or off. */
415 3 : cpp_opts->deps.modules = false;
416 3 : break;
417 :
418 5888 : case OPT_MQ:
419 5888 : case OPT_MT:
420 5888 : deps_seen = true;
421 5888 : defer_opt (code, arg);
422 5888 : break;
423 :
424 43 : case OPT_P:
425 43 : flag_no_line_commands = 1;
426 43 : break;
427 :
428 60 : case OPT_U:
429 60 : defer_opt (code, arg);
430 60 : break;
431 :
432 10933 : case OPT_Wall:
433 : /* ??? Don't add new options here. Use LangEnabledBy in c.opt. */
434 :
435 10933 : cpp_opts->warn_num_sign_change = value;
436 10933 : break;
437 :
438 11019 : case OPT_Wunknown_pragmas:
439 : /* Set to greater than 1, so that even unknown pragmas in
440 : system headers will be warned about. */
441 : /* ??? There is no way to handle this automatically for now. */
442 11019 : warn_unknown_pragmas = value * 2;
443 11019 : break;
444 :
445 3960 : case OPT_ansi:
446 3960 : if (!c_dialect_cxx ())
447 3814 : set_std_c89 (false, true);
448 : else
449 146 : set_std_cxx98 (true);
450 : break;
451 :
452 1635 : case OPT_d:
453 1635 : handle_OPT_d (arg);
454 1635 : break;
455 :
456 12345 : case OPT_Wabi_:
457 12345 : warn_abi = true;
458 12345 : if (value == 1)
459 : {
460 0 : warning (0, "%<-Wabi=1%> is not supported, using =2");
461 0 : value = 2;
462 : }
463 12345 : warn_abi_version = value;
464 12345 : break;
465 :
466 18 : case OPT_fcanonical_system_headers:
467 18 : cpp_opts->canonical_system_headers = value;
468 18 : break;
469 :
470 12 : case OPT_fcond_mismatch:
471 12 : if (!c_dialect_cxx ())
472 : {
473 12 : flag_cond_mismatch = value;
474 12 : break;
475 : }
476 0 : warning (0, "switch %qs is no longer supported", option->opt_text);
477 0 : break;
478 :
479 308 : case OPT_fbuiltin_:
480 308 : if (value)
481 : result = false;
482 : else
483 308 : disable_builtin_function (arg);
484 : break;
485 :
486 1100 : case OPT_fdirectives_only:
487 1100 : cpp_opts->directives_only = value;
488 1100 : break;
489 :
490 7 : case OPT_fdollars_in_identifiers:
491 7 : cpp_opts->dollars_in_ident = value;
492 7 : break;
493 :
494 8 : case OPT_fmacro_prefix_map_:
495 8 : add_macro_prefix_map (arg);
496 8 : break;
497 :
498 679 : case OPT_ffreestanding:
499 679 : value = !value;
500 : /* Fall through. */
501 687 : case OPT_fhosted:
502 687 : flag_hosted = value;
503 687 : flag_no_builtin = !value;
504 687 : break;
505 :
506 0 : case OPT_fconstant_string_class_:
507 0 : constant_string_class_name = arg;
508 0 : break;
509 :
510 0 : case OPT_fextended_identifiers:
511 0 : cpp_opts->extended_identifiers = value;
512 0 : break;
513 :
514 4 : case OPT_fmax_include_depth_:
515 4 : cpp_opts->max_include_depth = value;
516 4 : break;
517 :
518 4 : case OPT_foperator_names:
519 4 : cpp_opts->operator_names = value;
520 4 : break;
521 :
522 0 : case OPT_fpch_deps:
523 0 : cpp_opts->restore_pch_deps = value;
524 0 : break;
525 :
526 477 : case OPT_fpch_preprocess:
527 477 : flag_pch_preprocess = value;
528 477 : break;
529 :
530 1151 : case OPT_fpermissive:
531 1151 : flag_permissive = value;
532 1151 : global_dc->m_permissive = value;
533 1151 : break;
534 :
535 529 : case OPT_fpreprocessed:
536 529 : cpp_opts->preprocessed = value;
537 529 : break;
538 :
539 2 : case OPT_fdebug_cpp:
540 2 : cpp_opts->debug = value;
541 2 : break;
542 :
543 1 : case OPT_ftrack_macro_expansion:
544 1 : if (value)
545 0 : value = 2;
546 : /* Fall Through. */
547 :
548 483 : case OPT_ftrack_macro_expansion_:
549 483 : if (arg && *arg != '\0')
550 482 : cpp_opts->track_macro_expansion = value;
551 : else
552 1 : cpp_opts->track_macro_expansion = 2;
553 : break;
554 :
555 108 : case OPT_fexec_charset_:
556 108 : cpp_opts->narrow_charset = arg;
557 108 : break;
558 :
559 2 : case OPT_fwide_exec_charset_:
560 2 : cpp_opts->wide_charset = arg;
561 2 : break;
562 :
563 93 : case OPT_finput_charset_:
564 93 : cpp_opts->input_charset = arg;
565 93 : cpp_opts->cpp_input_charset_explicit = 1;
566 93 : break;
567 :
568 29 : case OPT_ftemplate_depth_:
569 29 : max_tinst_depth = value;
570 29 : break;
571 :
572 21 : case OPT_fvisibility_inlines_hidden:
573 21 : visibility_options.inlines_hidden = value;
574 21 : break;
575 :
576 22 : case OPT_femit_struct_debug_baseonly:
577 22 : set_struct_debug_option (&global_options, loc, "base");
578 22 : break;
579 :
580 8 : case OPT_femit_struct_debug_reduced:
581 8 : set_struct_debug_option (&global_options, loc,
582 : "dir:ord:sys,dir:gen:any,ind:base");
583 8 : break;
584 :
585 12 : case OPT_femit_struct_debug_detailed_:
586 12 : set_struct_debug_option (&global_options, loc, arg);
587 12 : break;
588 :
589 17 : case OPT_fext_numeric_literals:
590 17 : cpp_opts->ext_numeric_literals = value;
591 17 : break;
592 :
593 4 : case OPT_idirafter:
594 4 : add_path (xstrdup (arg), INC_AFTER, 0, true);
595 4 : break;
596 :
597 9320 : case OPT_imacros:
598 9320 : case OPT_include:
599 9320 : defer_opt (code, arg);
600 9320 : break;
601 :
602 5370 : case OPT_imultilib:
603 5370 : imultilib = arg;
604 5370 : break;
605 :
606 205103 : case OPT_iprefix:
607 205103 : iprefix = arg;
608 205103 : break;
609 :
610 2918 : case OPT_iquote:
611 2918 : add_path (xstrdup (arg), INC_QUOTE, 0, true);
612 2918 : break;
613 :
614 0 : case OPT_isysroot:
615 0 : sysroot = arg;
616 0 : break;
617 :
618 460345 : case OPT_isystem:
619 460345 : add_path (xstrdup (arg), INC_SYSTEM, 0, true);
620 460345 : break;
621 :
622 0 : case OPT_iwithprefix:
623 0 : add_prefixed_path (arg, INC_SYSTEM);
624 0 : break;
625 :
626 0 : case OPT_iwithprefixbefore:
627 0 : add_prefixed_path (arg, INC_BRACKET);
628 0 : break;
629 :
630 84 : case OPT__embed_dir_:
631 84 : add_path (xstrdup (arg), INC_EMBED, 0, true);
632 84 : break;
633 :
634 979 : case OPT_lang_asm:
635 979 : cpp_set_lang (parse_in, CLK_ASM);
636 979 : cpp_opts->dollars_in_ident = false;
637 979 : break;
638 :
639 60 : case OPT_nostdinc:
640 60 : std_inc = false;
641 60 : break;
642 :
643 109774 : case OPT_nostdinc__:
644 109774 : std_cxx_inc = false;
645 109774 : break;
646 :
647 207695 : case OPT_o:
648 207695 : if (!out_fname)
649 207695 : out_fname = arg;
650 : else
651 0 : error ("output filename specified twice");
652 : break;
653 :
654 0 : case OPT_print_objc_runtime_info:
655 0 : print_struct_values = 1;
656 0 : break;
657 :
658 2 : case OPT_remap:
659 2 : cpp_opts->remap = 1;
660 2 : break;
661 :
662 14079 : case OPT_std_c__98:
663 14079 : case OPT_std_gnu__98:
664 14079 : if (!preprocessing_asm_p)
665 14079 : set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
666 : break;
667 :
668 5652 : case OPT_std_c__11:
669 5652 : case OPT_std_gnu__11:
670 5652 : if (!preprocessing_asm_p)
671 5652 : set_std_cxx11 (code == OPT_std_c__11 /* ISO */);
672 : break;
673 :
674 1288 : case OPT_std_c__14:
675 1288 : case OPT_std_gnu__14:
676 1288 : if (!preprocessing_asm_p)
677 1288 : set_std_cxx14 (code == OPT_std_c__14 /* ISO */);
678 : break;
679 :
680 4176 : case OPT_std_c__17:
681 4176 : case OPT_std_gnu__17:
682 4176 : if (!preprocessing_asm_p)
683 4176 : set_std_cxx17 (code == OPT_std_c__17 /* ISO */);
684 : break;
685 :
686 31973 : case OPT_std_c__20:
687 31973 : case OPT_std_gnu__20:
688 31973 : if (!preprocessing_asm_p)
689 31973 : set_std_cxx20 (code == OPT_std_c__20 /* ISO */);
690 : break;
691 :
692 2068 : case OPT_std_c__23:
693 2068 : case OPT_std_gnu__23:
694 2068 : if (!preprocessing_asm_p)
695 2068 : set_std_cxx23 (code == OPT_std_c__23 /* ISO */);
696 : break;
697 :
698 23651 : case OPT_std_c__26:
699 23651 : case OPT_std_gnu__26:
700 23651 : if (!preprocessing_asm_p)
701 23651 : set_std_cxx26 (code == OPT_std_c__26 /* ISO */);
702 : break;
703 :
704 191 : case OPT_std_c90:
705 191 : case OPT_std_iso9899_199409:
706 191 : if (!preprocessing_asm_p)
707 191 : set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
708 : break;
709 :
710 2953 : case OPT_std_gnu90:
711 2953 : if (!preprocessing_asm_p)
712 2953 : set_std_c89 (false /* c94 */, false /* ISO */);
713 : break;
714 :
715 576 : case OPT_std_c99:
716 576 : if (!preprocessing_asm_p)
717 575 : set_std_c99 (true /* ISO */);
718 : break;
719 :
720 616 : case OPT_std_gnu99:
721 616 : if (!preprocessing_asm_p)
722 616 : set_std_c99 (false /* ISO */);
723 : break;
724 :
725 514 : case OPT_std_c11:
726 514 : if (!preprocessing_asm_p)
727 514 : set_std_c11 (true /* ISO */);
728 : break;
729 :
730 3712 : case OPT_std_gnu11:
731 3712 : if (!preprocessing_asm_p)
732 3712 : set_std_c11 (false /* ISO */);
733 : break;
734 :
735 42 : case OPT_std_c17:
736 42 : if (!preprocessing_asm_p)
737 42 : set_std_c17 (true /* ISO */);
738 : break;
739 :
740 784 : case OPT_std_gnu17:
741 784 : if (!preprocessing_asm_p)
742 784 : set_std_c17 (false /* ISO */);
743 : break;
744 :
745 874 : case OPT_std_c23:
746 874 : if (!preprocessing_asm_p)
747 874 : set_std_c23 (true /* ISO */);
748 : break;
749 :
750 204 : case OPT_std_gnu23:
751 204 : if (!preprocessing_asm_p)
752 204 : set_std_c23 (false /* ISO */);
753 : break;
754 :
755 177 : case OPT_std_c2y:
756 177 : if (!preprocessing_asm_p)
757 177 : set_std_c2y (true /* ISO */);
758 : break;
759 :
760 11 : case OPT_std_gnu2y:
761 11 : if (!preprocessing_asm_p)
762 11 : set_std_c2y (false /* ISO */);
763 : break;
764 :
765 20 : case OPT_trigraphs:
766 20 : cpp_opts->trigraphs = 1;
767 20 : break;
768 :
769 2927 : case OPT_traditional_cpp:
770 2927 : cpp_opts->traditional = 1;
771 2927 : break;
772 :
773 0 : case OPT_fsearch_include_path:
774 0 : cpp_opts->main_search = CMS_user;
775 0 : break;
776 :
777 2 : case OPT_fsearch_include_path_:
778 2 : if (!strcmp (arg, "user"))
779 0 : cpp_opts->main_search = CMS_user;
780 2 : else if (!strcmp (arg, "system"))
781 2 : cpp_opts->main_search = CMS_system;
782 : else
783 0 : error ("invalid argument %qs to %<-fsearch-include-path%>", arg);
784 : break;
785 :
786 113 : case OPT_v:
787 113 : verbose = true;
788 113 : break;
789 : }
790 :
791 3338485 : switch (c_language)
792 : {
793 1429142 : case clk_c:
794 1429142 : C_handle_option_auto (&global_options, &global_options_set,
795 : scode, arg, value,
796 : c_family_lang_mask, kind,
797 : loc, handlers, global_dc);
798 1429142 : break;
799 :
800 0 : case clk_objc:
801 0 : ObjC_handle_option_auto (&global_options, &global_options_set,
802 : scode, arg, value,
803 : c_family_lang_mask, kind,
804 : loc, handlers, global_dc);
805 0 : break;
806 :
807 1909343 : case clk_cxx:
808 1909343 : CXX_handle_option_auto (&global_options, &global_options_set,
809 : scode, arg, value,
810 : c_family_lang_mask, kind,
811 : loc, handlers, global_dc);
812 1909343 : break;
813 :
814 0 : case clk_objcxx:
815 0 : ObjCXX_handle_option_auto (&global_options, &global_options_set,
816 : scode, arg, value,
817 : c_family_lang_mask, kind,
818 : loc, handlers, global_dc);
819 0 : break;
820 :
821 0 : default:
822 0 : gcc_unreachable ();
823 : }
824 :
825 3338485 : cpp_handle_option_auto (&global_options, scode, cpp_opts);
826 3338485 : return result;
827 : }
828 :
829 : /* Default implementation of TARGET_HANDLE_C_OPTION. */
830 :
831 : bool
832 0 : default_handle_c_option (size_t code ATTRIBUTE_UNUSED,
833 : const char *arg ATTRIBUTE_UNUSED,
834 : int value ATTRIBUTE_UNUSED)
835 : {
836 0 : return false;
837 : }
838 :
839 : /* Post-switch processing. */
840 : bool
841 208369 : c_common_post_options (const char **pfilename)
842 : {
843 : /* Canonicalize the input and output filenames. */
844 208369 : if (in_fnames == NULL)
845 : {
846 0 : in_fnames = XNEWVEC (const char *, 1);
847 0 : in_fnames[0] = "";
848 : }
849 208369 : else if (strcmp (in_fnames[0], "-") == 0)
850 : {
851 407 : if (pch_file)
852 0 : error ("cannot use %<-%> as input filename for a precompiled header");
853 :
854 407 : in_fnames[0] = "";
855 : }
856 :
857 208369 : if (out_fname == NULL || !strcmp (out_fname, "-"))
858 745 : out_fname = "";
859 :
860 208369 : if (cpp_opts->deps.style == DEPS_NONE)
861 202446 : check_deps_environment_vars ();
862 :
863 208369 : handle_deferred_opts ();
864 :
865 208369 : sanitize_cpp_opts ();
866 :
867 : /* Don't register include chains if under -fpreprocessed since we might not
868 : have correct sysroot this mode, and this may cause file permssion
869 : issue. */
870 208369 : if (!cpp_opts->preprocessed)
871 207840 : register_include_chains (parse_in, sysroot, iprefix, imultilib,
872 207840 : std_inc, std_cxx_inc && c_dialect_cxx (), verbose);
873 :
874 : #ifdef C_COMMON_OVERRIDE_OPTIONS
875 : /* Some machines may reject certain combinations of C
876 : language-specific options. */
877 : C_COMMON_OVERRIDE_OPTIONS;
878 : #endif
879 :
880 208369 : if (flag_excess_precision == EXCESS_PRECISION_DEFAULT)
881 355266 : flag_excess_precision = (flag_iso ? EXCESS_PRECISION_STANDARD
882 : : EXCESS_PRECISION_FAST);
883 :
884 : /* ISO C restricts floating-point expression contraction to within
885 : source-language expressions (-ffp-contract=on, currently an alias
886 : for -ffp-contract=off). */
887 208369 : if (flag_iso
888 58276 : && !c_dialect_cxx ()
889 6176 : && (OPTION_SET_P (flag_fp_contract_mode)
890 : == (enum fp_contract_mode) 0)
891 6176 : && flag_unsafe_math_optimizations == 0)
892 6171 : flag_fp_contract_mode = FP_CONTRACT_OFF;
893 :
894 : /* C language modes before C99 enable -fpermissive by default, but
895 : only if -pedantic-errors is not specified. Also treat
896 : -fno-permissive as a subset of -pedantic-errors that does not
897 : reject certain GNU extensions also present the defaults for later
898 : language modes. */
899 208369 : if (!c_dialect_cxx ()
900 110251 : && !flag_isoc99
901 6947 : && !global_dc->m_pedantic_errors
902 5938 : && !OPTION_SET_P (flag_permissive))
903 : {
904 5937 : flag_permissive = 1;
905 5937 : global_dc->m_permissive = 1;
906 : }
907 :
908 : /* If we are compiling C, and we are outside of a standards mode,
909 : we can permit the new values from ISO/IEC TS 18661-3 for
910 : FLT_EVAL_METHOD. Otherwise, we must restrict the possible values to
911 : the set specified in ISO C99/C11. */
912 208369 : if (!flag_iso
913 150093 : && !c_dialect_cxx ()
914 104075 : && (OPTION_SET_P (flag_permitted_flt_eval_methods)
915 : == PERMITTED_FLT_EVAL_METHODS_DEFAULT))
916 104074 : flag_permitted_flt_eval_methods = PERMITTED_FLT_EVAL_METHODS_TS_18661;
917 : else
918 104295 : flag_permitted_flt_eval_methods = PERMITTED_FLT_EVAL_METHODS_C11;
919 :
920 208369 : if (cxx_dialect >= cxx26)
921 23605 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
922 : flag_auto_var_init, AUTO_INIT_CXX26);
923 :
924 : /* The -Wtrivial-auto-var-init warning is useless for C++, where we always
925 : add .DEFERRED_INIT calls when some (vacuous) initializers are bypassed
926 : through jumps from switch condition to case/default label. */
927 208369 : if (c_dialect_cxx ())
928 98118 : warn_trivial_auto_var_init = 0;
929 :
930 : /* C23 Annex F does not permit certain built-in functions to raise
931 : "inexact". */
932 208369 : if (flag_isoc23)
933 97061 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
934 : flag_fp_int_builtin_inexact, 0);
935 :
936 : /* By default we use C99 inline semantics in GNU99 or C99 mode. C99
937 : inline semantics are not supported in GNU89 or C89 mode. */
938 208369 : if (flag_gnu89_inline == -1)
939 207926 : flag_gnu89_inline = !flag_isoc99;
940 443 : else if (!flag_gnu89_inline && !flag_isoc99)
941 1 : error ("%<-fno-gnu89-inline%> is only supported in GNU99 or C99 mode");
942 :
943 : /* Default to ObjC sjlj exception handling if NeXT runtime < v2. */
944 208369 : if (flag_objc_sjlj_exceptions < 0)
945 416738 : flag_objc_sjlj_exceptions = (flag_next_runtime && flag_objc_abi < 2);
946 208369 : if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
947 0 : flag_exceptions = 1;
948 :
949 : /* If -ffreestanding, -fno-hosted or -fno-builtin then disable
950 : pattern recognition. */
951 208369 : if (flag_no_builtin)
952 774 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
953 : flag_tree_loop_distribute_patterns, 0);
954 :
955 : /* -Woverlength-strings is off by default, but is enabled by -Wpedantic.
956 : It is never enabled in C++, as the minimum limit is not normative
957 : in that standard. */
958 208369 : if (c_dialect_cxx ())
959 98118 : warn_overlength_strings = 0;
960 :
961 : /* Wmain is enabled by default in C++ but not in C. */
962 : /* Wmain is disabled by default for -ffreestanding (!flag_hosted),
963 : even if -Wall or -Wpedantic was given (warn_main will be 2 if set
964 : by -Wall, 1 if set by -Wmain). */
965 208369 : if (warn_main == -1)
966 250506 : warn_main = (c_dialect_cxx () && flag_hosted) ? 1 : 0;
967 56877 : else if (warn_main == 2)
968 56556 : warn_main = flag_hosted ? 1 : 0;
969 :
970 : /* In C, -Wall and -Wc++-compat enable -Wenum-compare; if it has not
971 : yet been set, it is disabled by default. In C++, it is enabled
972 : by default. */
973 208369 : if (warn_enum_compare == -1)
974 198855 : warn_enum_compare = c_dialect_cxx () ? 1 : 0;
975 :
976 : /* For C++26 default to -Wkeyword-macro if -Wpedantic. */
977 208369 : if (cxx_dialect >= cxx26 && pedantic)
978 : {
979 14845 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
980 : warn_keyword_macro, 1);
981 14845 : if (warn_keyword_macro)
982 14844 : cpp_opts->cpp_warn_keyword_macro = warn_keyword_macro;
983 : }
984 :
985 : /* -Wpacked-bitfield-compat is on by default for the C languages. The
986 : warning is issued in stor-layout.cc which is not part of the front-end so
987 : we need to selectively turn it on here. */
988 208369 : if (warn_packed_bitfield_compat == -1)
989 208361 : warn_packed_bitfield_compat = 1;
990 :
991 : /* Special format checking options don't work without -Wformat; warn if
992 : they are used. */
993 208369 : if (!warn_format)
994 : {
995 197089 : warning (OPT_Wformat_y2k,
996 : "%<-Wformat-y2k%> ignored without %<-Wformat%>");
997 197089 : warning (OPT_Wformat_extra_args,
998 : "%<-Wformat-extra-args%> ignored without %<-Wformat%>");
999 197089 : warning (OPT_Wformat_zero_length,
1000 : "%<-Wformat-zero-length%> ignored without %<-Wformat%>");
1001 197089 : warning (OPT_Wformat_nonliteral,
1002 : "%<-Wformat-nonliteral%> ignored without %<-Wformat%>");
1003 197089 : warning (OPT_Wformat_contains_nul,
1004 : "%<-Wformat-contains-nul%> ignored without %<-Wformat%>");
1005 197089 : warning (OPT_Wformat_security,
1006 : "%<-Wformat-security%> ignored without %<-Wformat%>");
1007 : }
1008 :
1009 : /* -Wimplicit-function-declaration is enabled by default for C99. */
1010 208369 : if (warn_implicit_function_declaration == -1)
1011 200009 : warn_implicit_function_declaration = flag_isoc99;
1012 :
1013 : /* -Wimplicit-int is enabled by default for C99. */
1014 208369 : if (warn_implicit_int == -1)
1015 200066 : warn_implicit_int = flag_isoc99;
1016 :
1017 : /* -Wold-style-definition is enabled by default for C23. */
1018 208369 : if (warn_old_style_definition == -1)
1019 204072 : warn_old_style_definition = flag_isoc23;
1020 :
1021 : /* -Wshift-overflow is enabled by default in C99 and C++11 modes. */
1022 208369 : if (warn_shift_overflow == -1)
1023 395533 : warn_shift_overflow = cxx_dialect >= cxx11 || flag_isoc99;
1024 :
1025 : /* -Wmissing-parameter-name is enabled by -pedantic before C23,
1026 : and for -Wc11-c23-compat. */
1027 208369 : if (warn_missing_parameter_name == -1)
1028 208366 : warn_missing_parameter_name
1029 48288 : = ((pedantic && !flag_isoc23 && warn_c11_c23_compat != 0)
1030 256699 : || warn_c11_c23_compat > 0);
1031 :
1032 : /* Likewise for -Wfree-labels. */
1033 208369 : if (warn_free_labels == -1)
1034 48288 : warn_free_labels = ((pedantic && !flag_isoc23 && warn_c11_c23_compat != 0)
1035 256699 : || warn_c11_c23_compat > 0);
1036 :
1037 208369 : if (warn_deprecated_non_prototype == -1)
1038 208364 : warn_deprecated_non_prototype = warn_c11_c23_compat > 0;
1039 :
1040 : /* -Wshift-negative-value is enabled by -Wextra in C99 and C++11 to C++17
1041 : modes. */
1042 208369 : if (warn_shift_negative_value == -1)
1043 416698 : warn_shift_negative_value = (extra_warnings
1044 7775 : && (cxx_dialect >= cxx11 || flag_isoc99)
1045 417051 : && cxx_dialect < cxx20);
1046 :
1047 : /* -Wregister is enabled by default in C++17. */
1048 208369 : SET_OPTION_IF_UNSET (&global_options, &global_options_set, warn_register,
1049 : cxx_dialect >= cxx17);
1050 :
1051 : /* Explicit -Wdeprecated turns on warnings from later standards. */
1052 1630247 : auto deprecated_in = [&](enum cxx_dialect d)
1053 : {
1054 1421878 : if (OPTION_SET_P (warn_deprecated)) return !!warn_deprecated;
1055 1420390 : return (warn_deprecated && cxx_dialect >= d);
1056 : };
1057 :
1058 : /* -Wcomma-subscript is enabled by default in C++20. */
1059 208369 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
1060 : warn_comma_subscript,
1061 : cxx_dialect >= cxx23
1062 : || deprecated_in (cxx20));
1063 :
1064 : /* -Wvolatile is enabled by default in C++20. */
1065 208369 : SET_OPTION_IF_UNSET (&global_options, &global_options_set, warn_volatile,
1066 : deprecated_in (cxx20));
1067 :
1068 : /* -Wdeprecated-enum-enum-conversion is enabled by default in C++20. */
1069 208369 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
1070 : warn_deprecated_enum_enum_conv,
1071 : deprecated_in (cxx20));
1072 :
1073 : /* -Wdeprecated-enum-float-conversion is enabled by default in C++20. */
1074 208369 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
1075 : warn_deprecated_enum_float_conv,
1076 : deprecated_in (cxx20));
1077 :
1078 : /* -Wdeprecated-literal-operator is enabled by default in C++23. */
1079 208369 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
1080 : warn_deprecated_literal_operator,
1081 : deprecated_in (cxx23));
1082 :
1083 : /* -Warray-compare is enabled by default in C++20. */
1084 208369 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
1085 : warn_array_compare,
1086 : warn_array_compare || deprecated_in (cxx20));
1087 :
1088 : /* -Wdeprecated-variadic-comma-omission is enabled by default in C++26. */
1089 208369 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
1090 : warn_deprecated_variadic_comma_omission,
1091 : deprecated_in (cxx26));
1092 :
1093 : /* -Wtemplate-id-cdtor is enabled by default in C++20. */
1094 282677 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
1095 : warn_template_id_cdtor,
1096 : cxx_dialect >= cxx20 || warn_cxx20_compat);
1097 :
1098 : /* Declone C++ 'structors if -Os. */
1099 208369 : if (flag_declone_ctor_dtor == -1)
1100 208332 : flag_declone_ctor_dtor = optimize_size;
1101 :
1102 208369 : if (flag_abi_compat_version == 1)
1103 : {
1104 0 : warning (0, "%<-fabi-compat-version=1%> is not supported, using =2");
1105 0 : flag_abi_compat_version = 2;
1106 : }
1107 :
1108 : /* Change flag_abi_version to be the actual current ABI level, for the
1109 : benefit of c_cpp_builtins, and to make comparison simpler. */
1110 208369 : const int latest_abi_version = 21;
1111 : /* Possibly different for non-default ABI fixes within a release. */
1112 208369 : const int default_abi_version = latest_abi_version;
1113 : /* Generate compatibility aliases for ABI v18 (GCC 13) by default. */
1114 208369 : const int abi_compat_default = 18;
1115 :
1116 208369 : if (flag_abi_version > latest_abi_version)
1117 0 : warning (0, "%<-fabi-version=%d%> is not supported, using =%d",
1118 : flag_abi_version, latest_abi_version);
1119 :
1120 208369 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
1121 : flag_abi_version, default_abi_version);
1122 :
1123 : #define clamp(X) if (X == 0 || X > latest_abi_version) X = latest_abi_version
1124 208369 : clamp (flag_abi_version);
1125 : /* Don't clamp warn_abi_version, let it be 0 or out of bounds. */
1126 208369 : clamp (flag_abi_compat_version);
1127 : #undef clamp
1128 :
1129 : /* Default -Wabi= or -fabi-compat-version= from each other. */
1130 208369 : if (warn_abi_version == -1 && flag_abi_compat_version != -1)
1131 197 : warn_abi_version = flag_abi_compat_version;
1132 208172 : else if (flag_abi_compat_version == -1 && warn_abi_version != -1)
1133 12298 : flag_abi_compat_version = warn_abi_version;
1134 195874 : else if (warn_abi_version == -1 && flag_abi_compat_version == -1)
1135 : {
1136 195829 : warn_abi_version = 0;
1137 195829 : if (flag_abi_version == default_abi_version)
1138 195594 : flag_abi_compat_version = abi_compat_default;
1139 : else
1140 235 : flag_abi_compat_version = latest_abi_version;
1141 : }
1142 :
1143 : /* Allow warnings vs ABI versions beyond what we currently support. */
1144 208369 : if (warn_abi_version == 0)
1145 195844 : warn_abi_version = 1000;
1146 :
1147 : /* By default, enable the new inheriting constructor semantics along with ABI
1148 : 11. New and old should coexist fine, but it is a change in what
1149 : artificial symbols are generated. */
1150 416482 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
1151 : flag_new_inheriting_ctors,
1152 : abi_version_at_least (11));
1153 :
1154 : /* For GCC 7, only enable DR150 resolution by default if -std=c++17. */
1155 208369 : SET_OPTION_IF_UNSET (&global_options, &global_options_set, flag_new_ttp,
1156 : cxx_dialect >= cxx17);
1157 :
1158 : /* C++11 guarantees forward progress. */
1159 391303 : SET_OPTION_IF_UNSET (&global_options, &global_options_set, flag_finite_loops,
1160 : optimize >= 2 && cxx_dialect >= cxx11);
1161 :
1162 : /* It's OK to discard calls to pure/const functions that might throw. */
1163 208369 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
1164 : flag_delete_dead_exceptions, true);
1165 :
1166 208369 : if (cxx_dialect >= cxx11)
1167 : {
1168 : /* If we're allowing C++0x constructs, don't warn about C++98
1169 : identifiers which are keywords in C++0x. */
1170 83963 : warn_cxx11_compat = 0;
1171 83963 : cpp_opts->cpp_warn_cxx11_compat = 0;
1172 :
1173 83963 : if (warn_narrowing == -1)
1174 81771 : warn_narrowing = 1;
1175 :
1176 : /* Unless -f{,no-}ext-numeric-literals has been used explicitly,
1177 : for -std=c++{11,14,17,20,23,26} default to
1178 : -fno-ext-numeric-literals. */
1179 83963 : if (flag_iso && !OPTION_SET_P (flag_ext_numeric_literals))
1180 43228 : cpp_opts->ext_numeric_literals = 0;
1181 : }
1182 124406 : else if (warn_narrowing == -1)
1183 123913 : warn_narrowing = 0;
1184 :
1185 208369 : if (cxx_dialect >= cxx20)
1186 : {
1187 : /* Don't warn about C++20 compatibility changes in C++20 or later. */
1188 72885 : warn_cxx20_compat = 0;
1189 72885 : cpp_opts->cpp_warn_cxx20_compat = 0;
1190 : }
1191 208369 : if (cxx_dialect >= cxx26)
1192 : /* Don't warn about C++26 compatibility changes in C++26 or later. */
1193 23605 : warn_cxx26_compat = 0;
1194 :
1195 : /* C++17 has stricter evaluation order requirements; let's use some of them
1196 : for earlier C++ as well, so chaining works as expected. */
1197 208369 : if (c_dialect_cxx ()
1198 98118 : && flag_strong_eval_order == -1)
1199 119164 : flag_strong_eval_order = (cxx_dialect >= cxx17 ? 2 : 1);
1200 :
1201 208369 : if (flag_implicit_constexpr && cxx_dialect < cxx14)
1202 0 : flag_implicit_constexpr = false;
1203 :
1204 : /* Global sized deallocation is new in C++14. */
1205 208369 : if (flag_sized_deallocation == -1)
1206 208365 : flag_sized_deallocation = (cxx_dialect >= cxx14);
1207 :
1208 : /* Pedwarn about invalid constexpr functions before C++23. */
1209 208369 : if (warn_invalid_constexpr == -1)
1210 208353 : warn_invalid_constexpr = (cxx_dialect < cxx23);
1211 :
1212 : /* char8_t support is implicitly enabled in C++20 and C23. */
1213 208369 : if (flag_char8_t == -1)
1214 378150 : flag_char8_t = (cxx_dialect >= cxx20) || flag_isoc23;
1215 208369 : cpp_opts->unsigned_utf8char = flag_char8_t ? 1 : cpp_opts->unsigned_char;
1216 :
1217 208369 : cpp_opts->cpp_tabstop = global_dc->get_column_options ().m_tabstop;
1218 :
1219 208369 : if (flag_extern_tls_init)
1220 : {
1221 208367 : if (!TARGET_SUPPORTS_ALIASES || !SUPPORTS_WEAK)
1222 : {
1223 : /* Lazy TLS initialization for a variable in another TU requires
1224 : alias and weak reference support. */
1225 : if (flag_extern_tls_init > 0)
1226 : sorry ("external TLS initialization functions not supported "
1227 : "on this target");
1228 :
1229 : flag_extern_tls_init = 0;
1230 : }
1231 : else
1232 208367 : flag_extern_tls_init = 1;
1233 : }
1234 :
1235 : /* Enable by default only for C++ and C++ with ObjC extensions. */
1236 208369 : if (warn_return_type == -1 && c_dialect_cxx ())
1237 94574 : warn_return_type = 1;
1238 :
1239 : /* C++20 is the final version of concepts. We still use -fconcepts
1240 : to know when concepts are enabled. */
1241 208369 : if (cxx_dialect >= cxx20)
1242 72885 : flag_concepts = 1;
1243 :
1244 : /* Coroutines are also a C++20 feature. */
1245 208369 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
1246 : flag_coroutines, cxx_dialect >= cxx20);
1247 :
1248 : /* Enable lifetime extension of range based for temporaries for C++23. */
1249 208369 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
1250 : flag_range_for_ext_temps, cxx_dialect >= cxx23);
1251 :
1252 : /* Contracts are in C++26. */
1253 208369 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
1254 : flag_contracts, cxx_dialect >= cxx26);
1255 :
1256 : /* EnabledBy unfortunately can't specify value to use if set and
1257 : LangEnabledBy can't specify multiple options with &&. For -Wunused
1258 : or -Wunused -Wextra we want these to default to 3 unless user specified
1259 : some other level explicitly. */
1260 208369 : if (warn_unused_but_set_parameter == 1)
1261 7619 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
1262 : warn_unused_but_set_parameter, 3);
1263 208369 : if (warn_unused_but_set_variable == 1)
1264 10479 : SET_OPTION_IF_UNSET (&global_options, &global_options_set,
1265 : warn_unused_but_set_variable, 3);
1266 :
1267 : /* -fimmediate-escalation has no effect when immediate functions are not
1268 : supported. */
1269 208369 : if (flag_immediate_escalation && cxx_dialect < cxx20)
1270 135484 : flag_immediate_escalation = 0;
1271 :
1272 208369 : if (flag_reflection && cxx_dialect < cxx26)
1273 0 : error ("%<-freflection%> only supported with %<-std=c++26%> or "
1274 : "%<-std=gnu++26%>");
1275 :
1276 208369 : if (num_in_fnames > 1)
1277 0 : error ("too many filenames given; type %<%s %s%> for usage",
1278 : progname, "--help");
1279 :
1280 208369 : if (flag_preprocess_only)
1281 : {
1282 : /* Open the output now. We must do so even if flag_no_output is
1283 : on, because there may be other output than from the actual
1284 : preprocessing (e.g. from -dM). */
1285 6751 : if (out_fname[0] == '\0')
1286 745 : out_stream = stdout;
1287 : else
1288 6006 : out_stream = fopen (out_fname, "w");
1289 :
1290 6751 : if (out_stream == NULL)
1291 0 : fatal_error (input_location, "opening output file %s: %m", out_fname);
1292 :
1293 6751 : init_pp_output (out_stream);
1294 : }
1295 : else
1296 : {
1297 201618 : init_c_lex ();
1298 :
1299 : /* When writing a PCH file, avoid reading some other PCH file,
1300 : because the default address space slot then can't be used
1301 : for the output PCH file. */
1302 201618 : if (pch_file)
1303 : {
1304 440 : c_common_no_more_pch ();
1305 : /* Only -g0 and -gdwarf* are supported with PCH, for other
1306 : debug formats we warn here and refuse to load any PCH files. */
1307 440 : if (write_symbols != NO_DEBUG && write_symbols != DWARF2_DEBUG)
1308 0 : warning (OPT_Wdeprecated,
1309 : "the %qs debug info cannot be used with "
1310 : "pre-compiled headers",
1311 : debug_set_names (write_symbols & ~DWARF2_DEBUG));
1312 : /* Let libcpp know that the main file is a header so it won't
1313 : complain about things like #include_next and #pragma once. */
1314 440 : cpp_opts->main_search = CMS_header;
1315 : }
1316 201178 : else if (write_symbols != NO_DEBUG && write_symbols != DWARF2_DEBUG)
1317 342 : c_common_no_more_pch ();
1318 :
1319 : /* Yuk. WTF is this? I do know ObjC relies on it somewhere. */
1320 201618 : input_location = UNKNOWN_LOCATION;
1321 : }
1322 :
1323 208369 : struct cpp_callbacks *cb = cpp_get_callbacks (parse_in);
1324 208369 : cb->file_change = cb_file_change;
1325 208369 : cb->dir_change = cb_dir_change;
1326 208369 : if (lang_hooks.preprocess_options)
1327 98118 : lang_hooks.preprocess_options (parse_in);
1328 208369 : cpp_post_options (parse_in);
1329 208369 : init_global_opts_from_cpp (&global_options, cpp_get_options (parse_in));
1330 : /* For C++23 and explicit -finput-charset=UTF-8, turn on -Winvalid-utf8
1331 : by default and make it a pedwarn unless -Wno-invalid-utf8. */
1332 208369 : if (cxx_dialect >= cxx23
1333 25670 : && cpp_opts->cpp_input_charset_explicit
1334 23 : && strcmp (cpp_opts->input_charset, "UTF-8") == 0
1335 21 : && (cpp_opts->cpp_warn_invalid_utf8
1336 16 : || !global_options_set.x_warn_invalid_utf8))
1337 : {
1338 18 : global_options.x_warn_invalid_utf8 = 1;
1339 28 : cpp_opts->cpp_warn_invalid_utf8 = cpp_opts->cpp_pedantic ? 2 : 1;
1340 : }
1341 :
1342 : /* Let diagnostics infrastructure know how to convert input files the same
1343 : way libcpp will do it, namely using the configured input charset and
1344 : skipping a UTF-8 BOM if present. */
1345 208369 : diagnostic_initialize_input_context (global_dc,
1346 : c_common_input_charset_cb, true);
1347 208369 : input_location = UNKNOWN_LOCATION;
1348 :
1349 416738 : *pfilename = this_input_filename
1350 416738 : = cpp_read_main_file (parse_in, in_fnames[0],
1351 : /* We'll inject preamble pieces if this is
1352 : not preprocessed. */
1353 208369 : !cpp_opts->preprocessed);
1354 :
1355 : /* Don't do any compilation or preprocessing if there is no input file. */
1356 208369 : if (this_input_filename == NULL)
1357 : {
1358 0 : errorcount++;
1359 0 : return false;
1360 : }
1361 :
1362 208369 : if (flag_working_directory
1363 41618 : && flag_preprocess_only && !flag_no_line_commands)
1364 2219 : pp_dir_change (parse_in, get_src_pwd ());
1365 :
1366 : /* Disable LTO output when outputting a precompiled header. */
1367 208369 : if (pch_file && flag_lto)
1368 : {
1369 0 : flag_lto = 0;
1370 0 : flag_generate_lto = 0;
1371 : }
1372 :
1373 208369 : return flag_preprocess_only;
1374 : }
1375 :
1376 : /* Front end initialization common to C, ObjC and C++. */
1377 : bool
1378 208161 : c_common_init (void)
1379 : {
1380 : /* Set up preprocessor arithmetic. Must be done after call to
1381 : c_common_nodes_and_builtins for type nodes to be good. */
1382 208161 : cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1383 208161 : cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1384 208161 : cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1385 208161 : cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1386 208161 : cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1387 208161 : cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1388 :
1389 : /* This can't happen until after wchar_precision and bytes_big_endian
1390 : are known. */
1391 208161 : cpp_init_iconv (parse_in);
1392 :
1393 208161 : if (version_flag)
1394 : {
1395 110 : int i;
1396 110 : fputs ("Compiler executable checksum: ", stderr);
1397 1980 : for (i = 0; i < 16; i++)
1398 1760 : fprintf (stderr, "%02x", executable_checksum[i]);
1399 110 : putc ('\n', stderr);
1400 : }
1401 :
1402 : /* Has to wait until now so that cpplib has its hash table. */
1403 208161 : init_pragma ();
1404 :
1405 208161 : if (flag_preprocess_only)
1406 : {
1407 6746 : c_init_preprocess ();
1408 6746 : c_finish_options ();
1409 6746 : preprocess_file (parse_in);
1410 6746 : return false;
1411 : }
1412 :
1413 : return true;
1414 : }
1415 :
1416 : /* Initialize the integrated preprocessor after debug output has been
1417 : initialized; loop over each input file. */
1418 : void
1419 201415 : c_common_parse_file (void)
1420 : {
1421 201415 : auto dumps = g->get_dumps ();
1422 201415 : for (unsigned int i = 0;;)
1423 : {
1424 201415 : c_finish_options ();
1425 : /* Open the dump file to use for the original dump output
1426 : here, to be used during parsing for the current file. */
1427 201415 : dumps->dump_start (TDI_original, &dump_flags);
1428 201415 : pch_init ();
1429 201415 : push_file_scope ();
1430 201415 : c_parse_file ();
1431 201123 : pop_file_scope ();
1432 : /* And end the main input file, if the debug writer wants it */
1433 201123 : if (debug_hooks->start_end_main_source_file)
1434 39210 : (*debug_hooks->end_source_file) (0);
1435 201123 : if (++i >= num_in_fnames)
1436 : break;
1437 0 : cpp_undef_all (parse_in);
1438 0 : cpp_clear_file_cache (parse_in);
1439 0 : this_input_filename
1440 0 : = cpp_read_main_file (parse_in, in_fnames[i]);
1441 : /* If an input file is missing, abandon further compilation.
1442 : cpplib has issued a diagnostic. */
1443 0 : if (!this_input_filename)
1444 : break;
1445 0 : dumps->dump_finish (TDI_original);
1446 : }
1447 :
1448 201123 : c_parse_final_cleanups ();
1449 201111 : dumps->dump_finish (TDI_original);
1450 201111 : }
1451 :
1452 : /* Common finish hook for the C, ObjC and C++ front ends. */
1453 : void
1454 207663 : c_common_finish (void)
1455 : {
1456 207663 : FILE *deps_stream = NULL;
1457 207663 : FILE *fdeps_stream = NULL;
1458 :
1459 : /* Note that we write the dependencies even if there are errors. This is
1460 : useful for handling outdated generated headers that now trigger errors
1461 : (for example, with #error) which would be resolved by re-generating
1462 : them. In a sense, this complements -MG. */
1463 207663 : if (cpp_opts->deps.style != DEPS_NONE)
1464 : {
1465 : /* If -M or -MM was seen without -MF, default output to the
1466 : output stream. */
1467 5918 : if (!deps_file)
1468 25 : deps_stream = out_stream;
1469 5893 : else if (deps_file[0] == '-' && deps_file[1] == '\0')
1470 0 : deps_stream = stdout;
1471 : else
1472 : {
1473 11786 : deps_stream = fopen (deps_file, deps_append ? "a" : "w");
1474 5893 : if (!deps_stream)
1475 0 : fatal_error (input_location, "opening dependency file %s: %m",
1476 : deps_file);
1477 : }
1478 : }
1479 :
1480 : /* When we call cpp_finish (), it may generate some diagnostics using
1481 : locations it remembered from the preprocessing phase, e.g. for
1482 : -Wunused-macros. So inform c_cpp_diagnostic () not to override those
1483 : locations with input_location, which would be incorrect now. */
1484 207663 : override_libcpp_locations = false;
1485 :
1486 207663 : if (cpp_opts->deps.fdeps_format != FDEPS_FMT_NONE)
1487 : {
1488 36 : if (!fdeps_file)
1489 0 : fdeps_stream = out_stream;
1490 36 : else if (fdeps_file[0] == '-' && fdeps_file[1] == '\0')
1491 0 : fdeps_stream = stdout;
1492 : else
1493 : {
1494 36 : fdeps_stream = fopen (fdeps_file, "w");
1495 36 : if (!fdeps_stream)
1496 0 : fatal_error (input_location, "opening dependency file %s: %m",
1497 : fdeps_file);
1498 : }
1499 36 : if (fdeps_stream == deps_stream && fdeps_stream != stdout)
1500 0 : fatal_error (input_location, "%<-MF%> and %<-fdeps-file=%> cannot share an output file %s: %m",
1501 0 : fdeps_file ? fdeps_file : out_fname);
1502 : }
1503 :
1504 : /* For performance, avoid tearing down cpplib's internal structures
1505 : with cpp_destroy (). */
1506 207663 : cpp_finish (parse_in, deps_stream, fdeps_stream);
1507 :
1508 5918 : if (deps_stream && deps_stream != out_stream && deps_stream != stdout
1509 213556 : && (ferror (deps_stream) || fclose (deps_stream)))
1510 0 : fatal_error (input_location, "closing dependency file %s: %m", deps_file);
1511 :
1512 207663 : if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1513 0 : fatal_error (input_location, "when writing output to %s: %m", out_fname);
1514 207663 : }
1515 :
1516 : /* Either of two environment variables can specify output of
1517 : dependencies. Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1518 : DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1519 : and DEPS_TARGET is the target to mention in the deps. They also
1520 : result in dependency information being appended to the output file
1521 : rather than overwriting it, and like Sun's compiler
1522 : SUNPRO_DEPENDENCIES suppresses the dependency on the main file. */
1523 : static void
1524 202446 : check_deps_environment_vars (void)
1525 : {
1526 202446 : char *spec;
1527 :
1528 202446 : spec = getenv ("DEPENDENCIES_OUTPUT");
1529 202446 : if (spec)
1530 0 : cpp_opts->deps.style = DEPS_USER;
1531 : else
1532 : {
1533 202446 : spec = getenv ("SUNPRO_DEPENDENCIES");
1534 202446 : if (spec)
1535 : {
1536 0 : cpp_opts->deps.style = DEPS_SYSTEM;
1537 0 : cpp_opts->deps.ignore_main_file = true;
1538 : }
1539 : }
1540 :
1541 0 : if (spec)
1542 : {
1543 : /* Find the space before the DEPS_TARGET, if there is one. */
1544 0 : char *s = strchr (spec, ' ');
1545 0 : if (s)
1546 : {
1547 : /* Let the caller perform MAKE quoting. */
1548 0 : defer_opt (OPT_MT, s + 1);
1549 0 : *s = '\0';
1550 : }
1551 :
1552 : /* Command line -MF overrides environment variables and default. */
1553 0 : if (!deps_file)
1554 0 : deps_file = spec;
1555 :
1556 0 : deps_append = 1;
1557 0 : deps_seen = true;
1558 : }
1559 202446 : }
1560 :
1561 : /* Handle deferred command line switches. */
1562 : static void
1563 208369 : handle_deferred_opts (void)
1564 : {
1565 : /* Avoid allocating the deps buffer if we don't need it.
1566 : (This flag may be true without there having been -MT or -MQ
1567 : options, but we'll still need the deps buffer.) */
1568 208369 : if (!deps_seen)
1569 : return;
1570 :
1571 5922 : if (mkdeps *deps = cpp_get_deps (parse_in))
1572 35028 : for (unsigned i = 0; i < deferred_count; i++)
1573 : {
1574 29130 : struct deferred_opt *opt = &deferred_opts[i];
1575 :
1576 29130 : if (opt->code == OPT_MT || opt->code == OPT_MQ)
1577 5888 : deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1578 23242 : else if (opt->code == OPT_fdeps_target_)
1579 42 : fdeps_add_target (deps, opt->arg, true);
1580 : }
1581 : }
1582 :
1583 : /* These settings are appropriate for GCC, but not necessarily so for
1584 : cpplib as a library. */
1585 : static void
1586 208369 : sanitize_cpp_opts (void)
1587 : {
1588 : /* If we don't know what style of dependencies to output, complain
1589 : if any other dependency switches have been given. */
1590 208369 : if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1591 24 : error ("to generate dependencies you must specify either %<-M%> "
1592 : "or %<-MM%>");
1593 :
1594 : /* -dM and dependencies suppress normal output; do it here so that
1595 : the last -d[MDN] switch overrides earlier ones. */
1596 208369 : if (flag_dump_macros == 'M')
1597 80 : flag_no_output = 1;
1598 :
1599 : /* By default, -fdirectives-only implies -dD. This allows subsequent phases
1600 : to perform proper macro expansion. */
1601 208369 : if (cpp_opts->directives_only && !cpp_opts->preprocessed && !flag_dump_macros)
1602 80 : flag_dump_macros = 'D';
1603 :
1604 : /* Disable -dD, -dN and -dI if normal output is suppressed. Allow
1605 : -dM since at least glibc relies on -M -dM to work. */
1606 : /* Also, flag_no_output implies flag_no_line_commands, always. */
1607 208369 : if (flag_no_output)
1608 : {
1609 110 : if (flag_dump_macros != 'M')
1610 30 : flag_dump_macros = 0;
1611 110 : flag_dump_includes = 0;
1612 110 : flag_no_line_commands = 1;
1613 : }
1614 208259 : else if (cpp_opts->deps.missing_files)
1615 1 : error ("%<-MG%> may only be used with %<-M%> or %<-MM%>");
1616 :
1617 208369 : cpp_opts->unsigned_char = !flag_signed_char;
1618 208369 : cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1619 :
1620 : /* Wlong-long is disabled by default. It is enabled by:
1621 : [-Wpedantic | -Wtraditional] -std=[gnu|c]++98 ; or
1622 : [-Wpedantic | -Wtraditional] -std=non-c99
1623 :
1624 : Either -Wlong-long or -Wno-long-long override any other settings.
1625 : ??? These conditions should be handled in c.opt. */
1626 208369 : if (warn_long_long == -1)
1627 : {
1628 159326 : warn_long_long = ((pedantic || warn_traditional)
1629 163058 : && (c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99));
1630 163034 : cpp_opts->cpp_warn_long_long = warn_long_long;
1631 : }
1632 :
1633 : /* If we're generating preprocessor output, emit current directory
1634 : if explicitly requested or if debugging information is enabled.
1635 : ??? Maybe we should only do it for debugging formats that
1636 : actually output the current directory? */
1637 208369 : if (flag_working_directory == -1)
1638 207100 : flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1639 :
1640 208369 : if (warn_implicit_fallthrough < 5)
1641 208365 : cpp_opts->cpp_warn_implicit_fallthrough = warn_implicit_fallthrough;
1642 : else
1643 4 : cpp_opts->cpp_warn_implicit_fallthrough = 0;
1644 :
1645 208369 : if (cpp_opts->directives_only)
1646 : {
1647 121 : if (cpp_warn_unused_macros)
1648 4 : error ("%<-fdirectives-only%> is incompatible "
1649 : "with %<-Wunused-macros%>");
1650 121 : if (cpp_opts->traditional)
1651 1 : error ("%<-fdirectives-only%> is incompatible with %<-traditional%>");
1652 : }
1653 208369 : }
1654 :
1655 : /* Add include path with a prefix at the front of its name. */
1656 : static void
1657 0 : add_prefixed_path (const char *suffix, incpath_kind chain)
1658 : {
1659 0 : char *path;
1660 0 : const char *prefix;
1661 0 : size_t prefix_len, suffix_len;
1662 :
1663 0 : suffix_len = strlen (suffix);
1664 0 : prefix = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1665 0 : prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1666 :
1667 0 : path = (char *) xmalloc (prefix_len + suffix_len + 1);
1668 0 : memcpy (path, prefix, prefix_len);
1669 0 : memcpy (path + prefix_len, suffix, suffix_len);
1670 0 : path[prefix_len + suffix_len] = '\0';
1671 :
1672 0 : add_path (path, chain, 0, false);
1673 0 : }
1674 :
1675 : /* Handle -D, -U, -A, -imacros, and the first -include. */
1676 : static void
1677 208161 : c_finish_options (void)
1678 : {
1679 208161 : if (!cpp_opts->preprocessed)
1680 : {
1681 207632 : const line_map_ordinary *bltin_map
1682 207632 : = linemap_check_ordinary (linemap_add (line_table, LC_RENAME, 0,
1683 : special_fname_builtin (), 0));
1684 207632 : cb_file_change (parse_in, bltin_map);
1685 207632 : linemap_line_start (line_table, 0, 1);
1686 :
1687 : /* Make sure all of the builtins about to be declared have
1688 : BUILTINS_LOCATION has their location_t. */
1689 207632 : cpp_force_token_locations (parse_in, BUILTINS_LOCATION);
1690 :
1691 207632 : cpp_init_builtins (parse_in, flag_hosted);
1692 207632 : c_cpp_builtins (parse_in);
1693 :
1694 : /* We're about to send user input to cpplib, so make it warn for
1695 : things that we previously (when we sent it internal definitions)
1696 : told it to not warn.
1697 :
1698 : C99 permits implementation-defined characters in identifiers.
1699 : The documented meaning of -std= is to turn off extensions that
1700 : conflict with the specified standard, and since a strictly
1701 : conforming program cannot contain a '$', we do not condition
1702 : their acceptance on the -std= setting. */
1703 207632 : cpp_opts->warn_dollars = (cpp_opts->cpp_pedantic && !cpp_opts->c99);
1704 :
1705 207632 : const line_map_ordinary *cmd_map
1706 207632 : = linemap_check_ordinary (linemap_add (line_table, LC_RENAME, 0,
1707 207632 : _("<command-line>"), 0));
1708 207632 : cb_file_change (parse_in, cmd_map);
1709 207632 : linemap_line_start (line_table, 0, 1);
1710 :
1711 207632 : bool fortify_seen_p = false;
1712 207632 : bool cxx_assert_seen_p = false;
1713 :
1714 : /* All command line defines must have the same location. */
1715 207632 : line_table->cmdline_location = line_table->highest_line;
1716 207632 : cpp_force_token_locations (parse_in, line_table->highest_line);
1717 386511 : for (size_t i = 0; i < deferred_count; i++)
1718 : {
1719 178879 : struct deferred_opt *opt = &deferred_opts[i];
1720 :
1721 178879 : if (opt->code == OPT_D)
1722 163560 : cpp_define (parse_in, opt->arg);
1723 15319 : else if (opt->code == OPT_U)
1724 60 : cpp_undef (parse_in, opt->arg);
1725 15259 : else if (opt->code == OPT_A)
1726 : {
1727 10 : if (opt->arg[0] == '-')
1728 2 : cpp_unassert (parse_in, opt->arg + 1);
1729 : else
1730 8 : cpp_assert (parse_in, opt->arg);
1731 : }
1732 :
1733 178879 : if (UNLIKELY (flag_hardened)
1734 83 : && (opt->code == OPT_D || opt->code == OPT_U))
1735 : {
1736 83 : if (!fortify_seen_p)
1737 79 : fortify_seen_p
1738 79 : = (!strncmp (opt->arg, "_FORTIFY_SOURCE", 15)
1739 79 : && (opt->arg[15] == '\0' || opt->arg[15] == '='));
1740 83 : if (!cxx_assert_seen_p)
1741 83 : cxx_assert_seen_p
1742 83 : = (!strncmp (opt->arg, "_GLIBCXX_ASSERTIONS", 19)
1743 83 : && (opt->arg[19] == '\0' || opt->arg[19] == '='));
1744 : }
1745 : }
1746 :
1747 207632 : if (flag_hardened)
1748 : {
1749 91 : if (!fortify_seen_p && optimize > 0)
1750 71 : cpp_define_formatted (parse_in, "_FORTIFY_SOURCE=%u",
1751 71 : targetm.fortify_source_default_level ());
1752 20 : else if (optimize == 0)
1753 20 : warning_at (UNKNOWN_LOCATION, OPT_Whardened,
1754 : "%<_FORTIFY_SOURCE%> is not enabled by %<-fhardened%> "
1755 : "because optimizations are turned off");
1756 : else
1757 0 : warning_at (UNKNOWN_LOCATION, OPT_Whardened,
1758 : "%<_FORTIFY_SOURCE%> is not enabled by %<-fhardened%> "
1759 : "because it was specified in %<-D%> or %<-U%>");
1760 91 : if (!cxx_assert_seen_p)
1761 87 : cpp_define (parse_in, "_GLIBCXX_ASSERTIONS");
1762 : else
1763 4 : warning_at (UNKNOWN_LOCATION, OPT_Whardened,
1764 : "%<_GLIBCXX_ASSERTIONS%> is not enabled by "
1765 : "%<-fhardened%> because it was specified in %<-D%> "
1766 : "or %<-U%>");
1767 : }
1768 :
1769 207632 : cpp_stop_forcing_token_locations (parse_in);
1770 : }
1771 529 : else if (cpp_opts->directives_only)
1772 41 : cpp_init_special_builtins (parse_in);
1773 :
1774 : /* Start the main input file, if the debug writer wants it. */
1775 208161 : if (debug_hooks->start_end_main_source_file
1776 41549 : && !flag_preprocess_only)
1777 39326 : (*debug_hooks->start_source_file) (0, this_input_filename);
1778 :
1779 208161 : if (!cpp_opts->preprocessed)
1780 : /* Handle -imacros after -D and -U. */
1781 386511 : for (size_t i = 0; i < deferred_count; i++)
1782 : {
1783 178879 : struct deferred_opt *opt = &deferred_opts[i];
1784 :
1785 178879 : if (opt->code == OPT_imacros
1786 178879 : && cpp_push_include (parse_in, opt->arg))
1787 : {
1788 : /* Disable push_command_line_include callback for now. */
1789 8 : include_cursor = deferred_count + 1;
1790 8 : cpp_scan_nooutput (parse_in);
1791 : }
1792 : }
1793 :
1794 208161 : include_cursor = 0;
1795 208161 : push_command_line_include ();
1796 208161 : }
1797 :
1798 : /* Give CPP the next file given by -include, if any. */
1799 : static void
1800 736063 : push_command_line_include (void)
1801 : {
1802 : /* This can happen if disabled by -imacros for example.
1803 : Punt so that we don't set "<command-line>" as the filename for
1804 : the header. */
1805 736063 : if (include_cursor > deferred_count)
1806 : return;
1807 :
1808 425019 : if (!done_preinclude)
1809 : {
1810 208161 : done_preinclude = true;
1811 208161 : if (flag_hosted && std_inc && !cpp_opts->preprocessed)
1812 : {
1813 207550 : const char *preinc = targetcm.c_preinclude ();
1814 207550 : if (preinc && cpp_push_default_include (parse_in, preinc))
1815 : return;
1816 : }
1817 : }
1818 :
1819 217469 : pch_cpp_save_state ();
1820 :
1821 604560 : while (include_cursor < deferred_count)
1822 : {
1823 178931 : struct deferred_opt *opt = &deferred_opts[include_cursor++];
1824 :
1825 357809 : if (!cpp_opts->preprocessed && opt->code == OPT_include
1826 188243 : && cpp_push_include (parse_in, opt->arg))
1827 : return;
1828 : }
1829 :
1830 208160 : if (include_cursor == deferred_count)
1831 : {
1832 208160 : include_cursor++;
1833 : /* -Wunused-macros should only warn about macros defined hereafter. */
1834 208160 : cpp_opts->warn_unused_macros = cpp_warn_unused_macros;
1835 : /* Restore the line map back to the main file. */
1836 208160 : if (!cpp_opts->preprocessed)
1837 : {
1838 207631 : cpp_change_file (parse_in, LC_RENAME, this_input_filename);
1839 207631 : if (lang_hooks.preprocess_main_file)
1840 : /* We're starting the main file. Inform the FE of that. */
1841 97859 : lang_hooks.preprocess_main_file
1842 97859 : (parse_in, line_table, LINEMAPS_LAST_ORDINARY_MAP (line_table));
1843 : }
1844 :
1845 : /* Set this here so the client can change the option if it wishes,
1846 : and after stacking the main file so we don't trace the main file. */
1847 208160 : line_table->trace_includes = cpp_opts->print_include_names;
1848 : }
1849 : }
1850 :
1851 : /* File change callback. Has to handle -include files. */
1852 : static void
1853 19992662 : cb_file_change (cpp_reader *reader, const line_map_ordinary *new_map)
1854 : {
1855 19992662 : if (flag_preprocess_only)
1856 154670 : pp_file_change (new_map);
1857 : else
1858 19837992 : fe_file_change (new_map);
1859 :
1860 19784893 : if (new_map && cpp_opts->preprocessed
1861 37966 : && lang_hooks.preprocess_main_file && MAIN_FILE_P (new_map)
1862 19995227 : && ORDINARY_MAP_STARTING_LINE_NUMBER (new_map))
1863 : /* We're starting the main file. Inform the FE of that. */
1864 450 : lang_hooks.preprocess_main_file (reader, line_table, new_map);
1865 :
1866 19992662 : if (new_map
1867 19784893 : && (new_map->reason == LC_ENTER || new_map->reason == LC_RENAME))
1868 : {
1869 : /* Signal to plugins that a file is included. This could happen
1870 : several times with the same file path, e.g. because of
1871 : several '#include' or '#line' directives... */
1872 10310057 : invoke_plugin_callbacks
1873 10310057 : (PLUGIN_INCLUDE_FILE,
1874 10310057 : const_cast<char*> (ORDINARY_MAP_FILE_NAME (new_map)));
1875 : }
1876 :
1877 19784893 : if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1878 : {
1879 527902 : pch_cpp_save_state ();
1880 527902 : push_command_line_include ();
1881 : }
1882 19992661 : }
1883 :
1884 : void
1885 53 : cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
1886 : {
1887 53 : if (!set_src_pwd (dir))
1888 0 : warning (0, "too late for # directive to set debug directory");
1889 53 : }
1890 :
1891 : /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1892 : extensions if ISO). There is no concept of gnu94. */
1893 : static void
1894 6958 : set_std_c89 (int c94, int iso)
1895 : {
1896 9911 : cpp_set_lang (parse_in, c94 ? CLK_STDC94 : iso ? CLK_STDC89 : CLK_GNUC89);
1897 6958 : flag_iso = iso;
1898 6958 : flag_no_asm = iso;
1899 6958 : flag_no_gnu_keywords = iso;
1900 6958 : flag_no_nonansi_builtin = iso;
1901 6958 : flag_isoc94 = c94;
1902 6958 : flag_isoc99 = 0;
1903 6958 : flag_isoc11 = 0;
1904 6958 : flag_isoc23 = 0;
1905 6958 : flag_isoc2y = 0;
1906 6958 : lang_hooks.name = "GNU C89";
1907 6958 : }
1908 :
1909 : /* Set the C 99 standard (without GNU extensions if ISO). */
1910 : static void
1911 1191 : set_std_c99 (int iso)
1912 : {
1913 1807 : cpp_set_lang (parse_in, iso ? CLK_STDC99 : CLK_GNUC99);
1914 1191 : flag_no_asm = iso;
1915 1191 : flag_no_nonansi_builtin = iso;
1916 1191 : flag_iso = iso;
1917 1191 : flag_isoc2y = 0;
1918 1191 : flag_isoc23 = 0;
1919 1191 : flag_isoc11 = 0;
1920 1191 : flag_isoc99 = 1;
1921 1191 : flag_isoc94 = 1;
1922 1191 : lang_hooks.name = "GNU C99";
1923 1191 : }
1924 :
1925 : /* Set the C 11 standard (without GNU extensions if ISO). */
1926 : static void
1927 4226 : set_std_c11 (int iso)
1928 : {
1929 7938 : cpp_set_lang (parse_in, iso ? CLK_STDC11 : CLK_GNUC11);
1930 4226 : flag_no_asm = iso;
1931 4226 : flag_no_nonansi_builtin = iso;
1932 4226 : flag_iso = iso;
1933 4226 : flag_isoc2y = 0;
1934 4226 : flag_isoc23 = 0;
1935 4226 : flag_isoc11 = 1;
1936 4226 : flag_isoc99 = 1;
1937 4226 : flag_isoc94 = 1;
1938 4226 : lang_hooks.name = "GNU C11";
1939 4226 : }
1940 :
1941 : /* Set the C 17 standard (without GNU extensions if ISO). */
1942 : static void
1943 826 : set_std_c17 (int iso)
1944 : {
1945 1610 : cpp_set_lang (parse_in, iso ? CLK_STDC17 : CLK_GNUC17);
1946 826 : flag_no_asm = iso;
1947 826 : flag_no_nonansi_builtin = iso;
1948 826 : flag_iso = iso;
1949 826 : flag_isoc2y = 0;
1950 826 : flag_isoc23 = 0;
1951 826 : flag_isoc11 = 1;
1952 826 : flag_isoc99 = 1;
1953 826 : flag_isoc94 = 1;
1954 826 : lang_hooks.name = "GNU C17";
1955 826 : }
1956 :
1957 : /* Set the C 23 standard (without GNU extensions if ISO). */
1958 : static void
1959 111399 : set_std_c23 (int iso)
1960 : {
1961 221924 : cpp_set_lang (parse_in, iso ? CLK_STDC23 : CLK_GNUC23);
1962 111399 : flag_no_asm = iso;
1963 111399 : flag_no_nonansi_builtin = iso;
1964 111399 : flag_iso = iso;
1965 111399 : flag_isoc2y = 0;
1966 111399 : flag_isoc23 = 1;
1967 111399 : flag_isoc11 = 1;
1968 111399 : flag_isoc99 = 1;
1969 111399 : flag_isoc94 = 1;
1970 111399 : lang_hooks.name = "GNU C23";
1971 111399 : }
1972 :
1973 : /* Set the C 2Y standard (without GNU extensions if ISO). */
1974 : static void
1975 188 : set_std_c2y (int iso)
1976 : {
1977 199 : cpp_set_lang (parse_in, iso ? CLK_STDC2Y : CLK_GNUC2Y);
1978 188 : flag_no_asm = iso;
1979 188 : flag_no_nonansi_builtin = iso;
1980 188 : flag_iso = iso;
1981 188 : flag_isoc2y = 1;
1982 188 : flag_isoc23 = 1;
1983 188 : flag_isoc11 = 1;
1984 188 : flag_isoc99 = 1;
1985 188 : flag_isoc94 = 1;
1986 188 : lang_hooks.name = "GNU C2Y";
1987 188 : }
1988 :
1989 :
1990 : /* Set the C++ 98 standard (without GNU extensions if ISO). */
1991 : static void
1992 14225 : set_std_cxx98 (int iso)
1993 : {
1994 19581 : cpp_set_lang (parse_in, iso ? CLK_CXX98 : CLK_GNUCXX);
1995 14225 : flag_no_gnu_keywords = iso;
1996 14225 : flag_no_nonansi_builtin = iso;
1997 14225 : flag_iso = iso;
1998 14225 : flag_isoc94 = 0;
1999 14225 : flag_isoc99 = 0;
2000 14225 : cxx_dialect = cxx98;
2001 14225 : lang_hooks.name = "GNU C++98";
2002 14225 : }
2003 :
2004 : /* Set the C++ 2011 standard (without GNU extensions if ISO). */
2005 : static void
2006 5652 : set_std_cxx11 (int iso)
2007 : {
2008 7092 : cpp_set_lang (parse_in, iso ? CLK_CXX11 : CLK_GNUCXX11);
2009 5652 : flag_no_gnu_keywords = iso;
2010 5652 : flag_no_nonansi_builtin = iso;
2011 5652 : flag_iso = iso;
2012 : /* C++11 includes the C99 standard library. */
2013 5652 : flag_isoc94 = 1;
2014 5652 : flag_isoc99 = 1;
2015 5652 : cxx_dialect = cxx11;
2016 5652 : lang_hooks.name = "GNU C++11";
2017 5652 : }
2018 :
2019 : /* Set the C++ 2014 standard (without GNU extensions if ISO). */
2020 : static void
2021 1288 : set_std_cxx14 (int iso)
2022 : {
2023 1565 : cpp_set_lang (parse_in, iso ? CLK_CXX14 : CLK_GNUCXX14);
2024 1288 : flag_no_gnu_keywords = iso;
2025 1288 : flag_no_nonansi_builtin = iso;
2026 1288 : flag_iso = iso;
2027 : /* C++14 includes the C99 standard library. */
2028 1288 : flag_isoc94 = 1;
2029 1288 : flag_isoc99 = 1;
2030 1288 : cxx_dialect = cxx14;
2031 1288 : lang_hooks.name = "GNU C++14";
2032 1288 : }
2033 :
2034 : /* Set the C++ 2017 standard (without GNU extensions if ISO). */
2035 : static void
2036 4176 : set_std_cxx17 (int iso)
2037 : {
2038 5104 : cpp_set_lang (parse_in, iso ? CLK_CXX17 : CLK_GNUCXX17);
2039 4176 : flag_no_gnu_keywords = iso;
2040 4176 : flag_no_nonansi_builtin = iso;
2041 4176 : flag_iso = iso;
2042 : /* C++17 includes the C11 standard library. */
2043 4176 : flag_isoc94 = 1;
2044 4176 : flag_isoc99 = 1;
2045 4176 : flag_isoc11 = 1;
2046 4176 : cxx_dialect = cxx17;
2047 4176 : lang_hooks.name = "GNU C++17";
2048 4176 : }
2049 :
2050 : /* Set the C++ 2020 standard (without GNU extensions if ISO). */
2051 : static void
2052 130092 : set_std_cxx20 (int iso)
2053 : {
2054 243645 : cpp_set_lang (parse_in, iso ? CLK_CXX20 : CLK_GNUCXX20);
2055 130092 : flag_no_gnu_keywords = iso;
2056 130092 : flag_no_nonansi_builtin = iso;
2057 130092 : flag_iso = iso;
2058 : /* C++20 includes the C11 standard library. */
2059 130092 : flag_isoc94 = 1;
2060 130092 : flag_isoc99 = 1;
2061 130092 : flag_isoc11 = 1;
2062 130092 : cxx_dialect = cxx20;
2063 130092 : lang_hooks.name = "GNU C++20";
2064 130092 : }
2065 :
2066 : /* Set the C++ 2023 standard (without GNU extensions if ISO). */
2067 : static void
2068 2068 : set_std_cxx23 (int iso)
2069 : {
2070 2616 : cpp_set_lang (parse_in, iso ? CLK_CXX23 : CLK_GNUCXX23);
2071 2068 : flag_no_gnu_keywords = iso;
2072 2068 : flag_no_nonansi_builtin = iso;
2073 2068 : flag_iso = iso;
2074 : /* C++23 includes the C11 standard library. */
2075 2068 : flag_isoc94 = 1;
2076 2068 : flag_isoc99 = 1;
2077 2068 : flag_isoc11 = 1;
2078 2068 : cxx_dialect = cxx23;
2079 2068 : lang_hooks.name = "GNU C++23";
2080 2068 : }
2081 :
2082 : /* Set the C++ 2026 standard (without GNU extensions if ISO). */
2083 : static void
2084 23651 : set_std_cxx26 (int iso)
2085 : {
2086 30561 : cpp_set_lang (parse_in, iso ? CLK_CXX26 : CLK_GNUCXX26);
2087 23651 : flag_no_gnu_keywords = iso;
2088 23651 : flag_no_nonansi_builtin = iso;
2089 23651 : flag_iso = iso;
2090 : /* C++26 includes the C11 standard library. */
2091 23651 : flag_isoc94 = 1;
2092 23651 : flag_isoc99 = 1;
2093 23651 : flag_isoc11 = 1;
2094 23651 : cxx_dialect = cxx26;
2095 23651 : lang_hooks.name = "GNU C++26";
2096 23651 : }
2097 :
2098 : /* Args to -d specify what to dump. Silently ignore
2099 : unrecognized options; they may be aimed at toplev.cc. */
2100 : static void
2101 1635 : handle_OPT_d (const char *arg)
2102 : {
2103 1635 : char c;
2104 :
2105 3270 : while ((c = *arg++) != '\0')
2106 1635 : switch (c)
2107 : {
2108 794 : case 'M': /* Dump macros only. */
2109 794 : case 'N': /* Dump names. */
2110 794 : case 'D': /* Dump definitions. */
2111 794 : case 'U': /* Dump used macros. */
2112 794 : flag_dump_macros = c;
2113 794 : break;
2114 :
2115 2 : case 'I':
2116 2 : flag_dump_includes = 1;
2117 2 : break;
2118 : }
2119 1635 : }
|
