xref: /netbsd-src/external/gpl3/gcc.old/dist/gcc/c-family/c-opts.c (revision 8feb0f0b7eaff0608f8350bbfa3098827b4bb91b)
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