1 /* C/ObjC/C++ command line option handling.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006 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 2, 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 COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "tree.h"
27 #include "c-common.h"
28 #include "c-pragma.h"
29 #include "flags.h"
30 #include "toplev.h"
31 #include "langhooks.h"
32 #include "tree-inline.h"
33 #include "diagnostic.h"
34 #include "intl.h"
35 #include "cppdefault.h"
36 #include "c-incpath.h"
37 #include "debug.h" /* For debug_hooks. */
38 #include "opts.h"
39 #include "options.h"
40 #include "mkdeps.h"
41
42 #ifndef DOLLARS_IN_IDENTIFIERS
43 # define DOLLARS_IN_IDENTIFIERS true
44 #endif
45
46 #ifndef TARGET_SYSTEM_ROOT
47 # define TARGET_SYSTEM_ROOT NULL
48 #endif
49
50 #ifndef TARGET_OPTF
51 #define TARGET_OPTF(ARG)
52 #endif
53
54 /* CPP's options. */
55 static cpp_options *cpp_opts;
56
57 /* Input filename. */
58 static const char *this_input_filename;
59
60 /* Filename and stream for preprocessed output. */
61 static const char *out_fname;
62 static FILE *out_stream;
63
64 /* Append dependencies to deps_file. */
65 static bool deps_append;
66
67 /* If dependency switches (-MF etc.) have been given. */
68 static bool deps_seen;
69
70 /* If -v seen. */
71 static bool verbose;
72
73 /* If -lang-fortran seen. */
74 static bool lang_fortran = false;
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 system root, if any. Overridden by -isysroot. */
83 static const char *sysroot = TARGET_SYSTEM_ROOT;
84
85 /* Zero disables all standard directories for headers. */
86 static bool std_inc = true;
87
88 /* Zero disables the C++-specific standard directories for headers. */
89 static bool std_cxx_inc = true;
90
91 /* If the quote chain has been split by -I-. */
92 static bool quote_chain_split;
93
94 /* If -Wunused-macros. */
95 static bool warn_unused_macros;
96
97 /* If -Wvariadic-macros. */
98 static bool warn_variadic_macros = true;
99
100 /* Number of deferred options. */
101 static size_t deferred_count;
102
103 /* Number of deferred options scanned for -include. */
104 static size_t include_cursor;
105
106 static void set_Wimplicit (int);
107 static void handle_OPT_d (const char *);
108 static void set_std_cxx98 (int);
109 static void set_std_c89 (int, int);
110 static void set_std_c99 (int);
111 static void check_deps_environment_vars (void);
112 static void handle_deferred_opts (void);
113 static void sanitize_cpp_opts (void);
114 static void add_prefixed_path (const char *, size_t);
115 static void push_command_line_include (void);
116 static void cb_file_change (cpp_reader *, const struct line_map *);
117 static void cb_dir_change (cpp_reader *, const char *);
118 static void finish_options (void);
119
120 #ifndef STDC_0_IN_SYSTEM_HEADERS
121 #define STDC_0_IN_SYSTEM_HEADERS 0
122 #endif
123
124 /* Holds switches parsed by c_common_handle_option (), but whose
125 handling is deferred to c_common_post_options (). */
126 static void defer_opt (enum opt_code, const char *);
127 static struct deferred_opt
128 {
129 enum opt_code code;
130 const char *arg;
131 } *deferred_opts;
132
133 /* Complain that switch CODE expects an argument but none was
134 provided. OPT was the command-line option. Return FALSE to get
135 the default message in opts.c, TRUE if we provide a specialized
136 one. */
137 bool
c_common_missing_argument(const char * opt,size_t code)138 c_common_missing_argument (const char *opt, size_t code)
139 {
140 switch (code)
141 {
142 default:
143 /* Pick up the default message. */
144 return false;
145
146 case OPT_fconstant_string_class_:
147 error ("no class name specified with %qs", opt);
148 break;
149
150 case OPT_A:
151 error ("assertion missing after %qs", opt);
152 break;
153
154 case OPT_D:
155 case OPT_U:
156 error ("macro name missing after %qs", opt);
157 break;
158
159 case OPT_F:
160 case OPT_I:
161 case OPT_idirafter:
162 case OPT_isysroot:
163 case OPT_isystem:
164 case OPT_iquote:
165 error ("missing path after %qs", opt);
166 break;
167
168 case OPT_MF:
169 case OPT_MD:
170 case OPT_MMD:
171 case OPT_include:
172 case OPT_imacros:
173 case OPT_o:
174 error ("missing filename after %qs", opt);
175 break;
176
177 case OPT_MQ:
178 case OPT_MT:
179 error ("missing makefile target after %qs", opt);
180 break;
181 }
182
183 return true;
184 }
185
186 /* Defer option CODE with argument ARG. */
187 static void
defer_opt(enum opt_code code,const char * arg)188 defer_opt (enum opt_code code, const char *arg)
189 {
190 deferred_opts[deferred_count].code = code;
191 deferred_opts[deferred_count].arg = arg;
192 deferred_count++;
193 }
194
195 /* Common initialization before parsing options. */
196 unsigned int
c_common_init_options(unsigned int argc,const char ** argv)197 c_common_init_options (unsigned int argc, const char **argv)
198 {
199 static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX};
200 unsigned int i, result;
201
202 /* This is conditionalized only because that is the way the front
203 ends used to do it. Maybe this should be unconditional? */
204 if (c_dialect_cxx ())
205 {
206 /* By default wrap lines at 80 characters. Is getenv
207 ("COLUMNS") preferable? */
208 diagnostic_line_cutoff (global_dc) = 80;
209 /* By default, emit location information once for every
210 diagnostic message. */
211 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
212 }
213
214 parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89,
215 ident_hash, &line_table);
216
217 cpp_opts = cpp_get_options (parse_in);
218 cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
219 cpp_opts->objc = c_dialect_objc ();
220
221 /* Reset to avoid warnings on internal definitions. We set it just
222 before passing on command-line options to cpplib. */
223 cpp_opts->warn_dollars = 0;
224
225 /* (TIGCC 20050217) Enable -fms-extensions by default. */
226 flag_ms_extensions = 1;
227
228 flag_const_strings = c_dialect_cxx ();
229 flag_exceptions = c_dialect_cxx ();
230 warn_pointer_arith = c_dialect_cxx ();
231
232 deferred_opts = XNEWVEC (struct deferred_opt, argc);
233
234 result = lang_flags[c_language];
235
236 if (c_language == clk_c)
237 {
238 /* If preprocessing assembly language, accept any of the C-family
239 front end options since the driver may pass them through. */
240 for (i = 1; i < argc; i++)
241 if (! strcmp (argv[i], "-lang-asm"))
242 {
243 result |= CL_C | CL_ObjC | CL_CXX | CL_ObjCXX;
244 break;
245 }
246
247 #ifdef CL_Fortran
248 for (i = 1; i < argc; i++)
249 if (! strcmp (argv[i], "-lang-fortran"))
250 {
251 result |= CL_Fortran;
252 break;
253 }
254 #endif
255 }
256
257 return result;
258 }
259
260 /* Handle switch SCODE with argument ARG. VALUE is true, unless no-
261 form of an -f or -W option was given. Returns 0 if the switch was
262 invalid, a negative number to prevent language-independent
263 processing in toplev.c (a hack necessary for the short-term). */
264 int
c_common_handle_option(size_t scode,const char * arg,int value)265 c_common_handle_option (size_t scode, const char *arg, int value)
266 {
267 const struct cl_option *option = &cl_options[scode];
268 enum opt_code code = (enum opt_code) scode;
269 int result = 1;
270
271 switch (code)
272 {
273 default:
274 if (cl_options[code].flags & (CL_C | CL_CXX | CL_ObjC | CL_ObjCXX))
275 break;
276 #ifdef CL_Fortran
277 if (lang_fortran && (cl_options[code].flags & (CL_Fortran)))
278 break;
279 #endif
280 result = 0;
281 break;
282
283 case OPT__output_pch_:
284 pch_file = arg;
285 break;
286
287 case OPT_A:
288 defer_opt (code, arg);
289 break;
290
291 case OPT_C:
292 cpp_opts->discard_comments = 0;
293 break;
294
295 case OPT_CC:
296 cpp_opts->discard_comments = 0;
297 cpp_opts->discard_comments_in_macro_exp = 0;
298 break;
299
300 case OPT_D:
301 defer_opt (code, arg);
302 break;
303
304 case OPT_E:
305 flag_preprocess_only = 1;
306 break;
307
308 case OPT_H:
309 cpp_opts->print_include_names = 1;
310 break;
311
312 case OPT_F:
313 TARGET_OPTF (xstrdup (arg));
314 break;
315
316 case OPT_I:
317 if (strcmp (arg, "-"))
318 add_path (xstrdup (arg), BRACKET, 0, true);
319 else
320 {
321 if (quote_chain_split)
322 error ("-I- specified twice");
323 quote_chain_split = true;
324 split_quote_chain ();
325 #if 0 /* (TIGCC 20050206) */
326 inform ("obsolete option -I- used, please use -iquote instead");
327 #endif /* 0 */
328 }
329 break;
330
331 case OPT_M:
332 case OPT_MM:
333 /* When doing dependencies with -M or -MM, suppress normal
334 preprocessed output, but still do -dM etc. as software
335 depends on this. Preprocessed output does occur if -MD, -MMD
336 or environment var dependency generation is used. */
337 cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER);
338 flag_no_output = 1;
339 cpp_opts->inhibit_warnings = 1;
340 break;
341
342 case OPT_MD:
343 case OPT_MMD:
344 cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER);
345 deps_file = arg;
346 break;
347
348 case OPT_MF:
349 deps_seen = true;
350 deps_file = arg;
351 break;
352
353 case OPT_MG:
354 deps_seen = true;
355 cpp_opts->deps.missing_files = true;
356 break;
357
358 case OPT_MP:
359 deps_seen = true;
360 cpp_opts->deps.phony_targets = true;
361 break;
362
363 case OPT_MQ:
364 case OPT_MT:
365 deps_seen = true;
366 defer_opt (code, arg);
367 break;
368
369 case OPT_P:
370 flag_no_line_commands = 1;
371 break;
372
373 case OPT_fworking_directory:
374 flag_working_directory = value;
375 break;
376
377 case OPT_U:
378 defer_opt (code, arg);
379 break;
380
381 case OPT_Wall:
382 set_Wunused (value);
383 set_Wformat (value);
384 set_Wimplicit (value);
385 warn_char_subscripts = value;
386 warn_missing_braces = value;
387 warn_parentheses = value;
388 warn_return_type = value;
389 warn_sequence_point = value; /* Was C only. */
390 if (c_dialect_cxx ())
391 warn_sign_compare = value;
392 warn_switch = value;
393 warn_strict_aliasing = value;
394
395 /* Only warn about unknown pragmas that are not in system
396 headers. */
397 warn_unknown_pragmas = value;
398
399 /* We save the value of warn_uninitialized, since if they put
400 -Wuninitialized on the command line, we need to generate a
401 warning about not using it without also specifying -O. */
402 if (warn_uninitialized != 1)
403 warn_uninitialized = (value ? 2 : 0);
404
405 if (!c_dialect_cxx ())
406 /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding
407 can turn it off only if it's not explicit. */
408 warn_main = value * 2;
409 else
410 {
411 /* C++-specific warnings. */
412 warn_nonvdtor = value;
413 warn_reorder = value;
414 warn_nontemplate_friend = value;
415 }
416
417 cpp_opts->warn_trigraphs = value;
418 cpp_opts->warn_comments = value;
419 cpp_opts->warn_num_sign_change = value;
420 cpp_opts->warn_multichar = value; /* Was C++ only. */
421
422 #if 0 /* (TIGCC 20060430) */
423 if (warn_pointer_sign == -1)
424 warn_pointer_sign = 1;
425 #endif /* 0 */
426 break;
427
428 case OPT_Wcomment:
429 case OPT_Wcomments:
430 cpp_opts->warn_comments = value;
431 break;
432
433 case OPT_Wdeprecated:
434 cpp_opts->warn_deprecated = value;
435 break;
436
437 case OPT_Wdiv_by_zero:
438 warn_div_by_zero = value;
439 break;
440
441 case OPT_Wendif_labels:
442 cpp_opts->warn_endif_labels = value;
443 break;
444
445 case OPT_Werror:
446 cpp_opts->warnings_are_errors = value;
447 global_dc->warning_as_error_requested = value;
448 break;
449
450 case OPT_Werror_implicit_function_declaration:
451 mesg_implicit_function_declaration = 2;
452 break;
453
454 case OPT_Wformat:
455 set_Wformat (value);
456 break;
457
458 case OPT_Wformat_:
459 set_Wformat (atoi (arg));
460 break;
461
462 case OPT_Wimplicit:
463 set_Wimplicit (value);
464 break;
465
466 case OPT_Wimport:
467 /* Silently ignore for now. */
468 break;
469
470 case OPT_Winvalid_pch:
471 cpp_opts->warn_invalid_pch = value;
472 break;
473
474 case OPT_Wmain:
475 if (value)
476 warn_main = 1;
477 else
478 warn_main = -1;
479 break;
480
481 case OPT_Wmissing_include_dirs:
482 cpp_opts->warn_missing_include_dirs = value;
483 break;
484
485 case OPT_Wmultichar:
486 cpp_opts->warn_multichar = value;
487 break;
488
489 case OPT_Wnormalized_:
490 if (!value || (arg && strcasecmp (arg, "none") == 0))
491 cpp_opts->warn_normalize = normalized_none;
492 else if (!arg || strcasecmp (arg, "nfkc") == 0)
493 cpp_opts->warn_normalize = normalized_KC;
494 else if (strcasecmp (arg, "id") == 0)
495 cpp_opts->warn_normalize = normalized_identifier_C;
496 else if (strcasecmp (arg, "nfc") == 0)
497 cpp_opts->warn_normalize = normalized_C;
498 else
499 error ("argument %qs to %<-Wnormalized%> not recognized", arg);
500 break;
501
502 case OPT_Wreturn_type:
503 warn_return_type = value;
504 break;
505
506 case OPT_Wstrict_null_sentinel:
507 warn_strict_null_sentinel = value;
508 break;
509
510 case OPT_Wsystem_headers:
511 cpp_opts->warn_system_headers = value;
512 break;
513
514 case OPT_Wtraditional:
515 cpp_opts->warn_traditional = value;
516 break;
517
518 case OPT_Wtrigraphs:
519 cpp_opts->warn_trigraphs = value;
520 break;
521
522 case OPT_Wundef:
523 cpp_opts->warn_undef = value;
524 break;
525
526 case OPT_Wunknown_pragmas:
527 /* Set to greater than 1, so that even unknown pragmas in
528 system headers will be warned about. */
529 warn_unknown_pragmas = value * 2;
530 break;
531
532 case OPT_Wunused_macros:
533 warn_unused_macros = value;
534 break;
535
536 case OPT_Wvariadic_macros:
537 warn_variadic_macros = value;
538 break;
539
540 case OPT_Wwrite_strings:
541 if (!c_dialect_cxx ())
542 flag_const_strings = value;
543 else
544 warn_write_strings = value;
545 break;
546
547 case OPT_ansi:
548 if (!c_dialect_cxx ())
549 set_std_c89 (false, true);
550 else
551 set_std_cxx98 (true);
552 break;
553
554 case OPT_d:
555 handle_OPT_d (arg);
556 break;
557
558 case OPT_fcond_mismatch:
559 if (!c_dialect_cxx ())
560 {
561 flag_cond_mismatch = value;
562 break;
563 }
564 /* Fall through. */
565
566 case OPT_fall_virtual:
567 case OPT_falt_external_templates:
568 case OPT_fenum_int_equiv:
569 case OPT_fexternal_templates:
570 case OPT_fguiding_decls:
571 case OPT_fhonor_std:
572 case OPT_fhuge_objects:
573 case OPT_flabels_ok:
574 case OPT_fname_mangling_version_:
575 case OPT_fnew_abi:
576 case OPT_fnonnull_objects:
577 case OPT_fsquangle:
578 case OPT_fstrict_prototype:
579 case OPT_fthis_is_variable:
580 case OPT_fvtable_thunks:
581 case OPT_fxref:
582 case OPT_fvtable_gc:
583 warning (0, "switch %qs is no longer supported", option->opt_text);
584 break;
585
586 case OPT_faccess_control:
587 flag_access_control = value;
588 break;
589
590 case OPT_fasm:
591 flag_no_asm = !value;
592 break;
593
594 case OPT_fbuiltin:
595 flag_no_builtin = !value;
596 break;
597
598 case OPT_fbuiltin_:
599 if (value)
600 result = 0;
601 else
602 disable_builtin_function (arg);
603 break;
604
605 case OPT_fdollars_in_identifiers:
606 cpp_opts->dollars_in_ident = value;
607 break;
608
609 case OPT_ffreestanding:
610 value = !value;
611 /* Fall through.... */
612 case OPT_fhosted:
613 flag_hosted = value;
614 flag_no_builtin = !value;
615 /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
616 if (!value && warn_main == 2)
617 warn_main = 0;
618 break;
619
620 case OPT_fshort_double:
621 flag_short_double = value;
622 break;
623
624 case OPT_fshort_enums:
625 flag_short_enums = value;
626 break;
627
628 case OPT_fshort_wchar:
629 flag_short_wchar = value;
630 break;
631
632 case OPT_fsigned_bitfields:
633 flag_signed_bitfields = value;
634 break;
635
636 case OPT_fsigned_char:
637 flag_signed_char = value;
638 break;
639
640 case OPT_funsigned_bitfields:
641 flag_signed_bitfields = !value;
642 break;
643
644 case OPT_funsigned_char:
645 flag_signed_char = !value;
646 break;
647
648 case OPT_fcheck_new:
649 flag_check_new = value;
650 break;
651
652 case OPT_fconserve_space:
653 flag_conserve_space = value;
654 break;
655
656 case OPT_fconst_strings:
657 flag_const_strings = value;
658 break;
659
660 case OPT_fconstant_string_class_:
661 constant_string_class_name = arg;
662 break;
663
664 case OPT_fdefault_inline:
665 flag_default_inline = value;
666 break;
667
668 case OPT_felide_constructors:
669 flag_elide_constructors = value;
670 break;
671
672 case OPT_fenforce_eh_specs:
673 flag_enforce_eh_specs = value;
674 break;
675
676 case OPT_fextended_identifiers:
677 cpp_opts->extended_identifiers = value;
678 break;
679
680 case OPT_ffor_scope:
681 flag_new_for_scope = value;
682 break;
683
684 case OPT_fgnu_keywords:
685 flag_no_gnu_keywords = !value;
686 break;
687
688 case OPT_fgnu_runtime:
689 flag_next_runtime = !value;
690 break;
691
692 case OPT_fhandle_exceptions:
693 warning (0, "-fhandle-exceptions has been renamed -fexceptions (and is now on by default)");
694 flag_exceptions = value;
695 break;
696
697 case OPT_fimplement_inlines:
698 flag_implement_inlines = value;
699 break;
700
701 case OPT_fimplicit_inline_templates:
702 flag_implicit_inline_templates = value;
703 break;
704
705 case OPT_fimplicit_templates:
706 flag_implicit_templates = value;
707 break;
708
709 case OPT_fms_extensions:
710 flag_ms_extensions = value;
711 break;
712
713 case OPT_fnext_runtime:
714 flag_next_runtime = value;
715 break;
716
717 case OPT_fnil_receivers:
718 flag_nil_receivers = value;
719 break;
720
721 case OPT_fnonansi_builtins:
722 flag_no_nonansi_builtin = !value;
723 break;
724
725 case OPT_foperator_names:
726 cpp_opts->operator_names = value;
727 break;
728
729 case OPT_foptional_diags:
730 flag_optional_diags = value;
731 break;
732
733 case OPT_fpch_deps:
734 cpp_opts->restore_pch_deps = value;
735 break;
736
737 case OPT_fpch_preprocess:
738 flag_pch_preprocess = value;
739 break;
740
741 case OPT_fpermissive:
742 flag_permissive = value;
743 break;
744
745 case OPT_fpreprocessed:
746 cpp_opts->preprocessed = value;
747 break;
748
749 case OPT_freplace_objc_classes:
750 flag_replace_objc_classes = value;
751 break;
752
753 case OPT_frepo:
754 flag_use_repository = value;
755 if (value)
756 flag_implicit_templates = 0;
757 break;
758
759 case OPT_frtti:
760 flag_rtti = value;
761 break;
762
763 case OPT_fshow_column:
764 cpp_opts->show_column = value;
765 break;
766
767 case OPT_fstats:
768 flag_detailed_statistics = value;
769 break;
770
771 case OPT_ftabstop_:
772 /* It is documented that we silently ignore silly values. */
773 if (value >= 1 && value <= 100)
774 cpp_opts->tabstop = value;
775 break;
776
777 case OPT_fexec_charset_:
778 cpp_opts->narrow_charset = arg;
779 break;
780
781 case OPT_fwide_exec_charset_:
782 cpp_opts->wide_charset = arg;
783 break;
784
785 case OPT_finput_charset_:
786 cpp_opts->input_charset = arg;
787 break;
788
789 case OPT_ftemplate_depth_:
790 max_tinst_depth = value;
791 break;
792
793 case OPT_fuse_cxa_atexit:
794 flag_use_cxa_atexit = value;
795 break;
796
797 case OPT_fvisibility_inlines_hidden:
798 visibility_options.inlines_hidden = value;
799 break;
800
801 case OPT_fweak:
802 flag_weak = value;
803 break;
804
805 case OPT_fthreadsafe_statics:
806 flag_threadsafe_statics = value;
807 break;
808
809 case OPT_fzero_link:
810 flag_zero_link = value;
811 break;
812
813 case OPT_gen_decls:
814 flag_gen_declaration = 1;
815 break;
816
817 case OPT_idirafter:
818 add_path (xstrdup (arg), AFTER, 0, true);
819 break;
820
821 case OPT_imacros:
822 case OPT_include:
823 defer_opt (code, arg);
824 break;
825
826 case OPT_iprefix:
827 iprefix = arg;
828 break;
829
830 case OPT_iquote:
831 add_path (xstrdup (arg), QUOTE, 0, true);
832 break;
833
834 case OPT_isysroot:
835 sysroot = arg;
836 break;
837
838 case OPT_isystem:
839 add_path (xstrdup (arg), SYSTEM, 0, true);
840 break;
841
842 case OPT_iwithprefix:
843 add_prefixed_path (arg, SYSTEM);
844 break;
845
846 case OPT_iwithprefixbefore:
847 add_prefixed_path (arg, BRACKET);
848 break;
849
850 case OPT_lang_asm:
851 cpp_set_lang (parse_in, CLK_ASM);
852 cpp_opts->dollars_in_ident = false;
853 break;
854
855 case OPT_lang_fortran:
856 lang_fortran = true;
857 break;
858
859 case OPT_lang_objc:
860 cpp_opts->objc = 1;
861 break;
862
863 case OPT_nostdinc:
864 std_inc = false;
865 break;
866
867 case OPT_nostdinc__:
868 std_cxx_inc = false;
869 break;
870
871 case OPT_o:
872 if (!out_fname)
873 out_fname = arg;
874 else
875 error ("output filename specified twice");
876 break;
877
878 /* We need to handle the -pedantic switches here, rather than in
879 c_common_post_options, so that a subsequent -Wno-endif-labels
880 is not overridden. */
881 case OPT_pedantic_errors:
882 cpp_opts->pedantic_errors = 1;
883 /* Fall through. */
884 case OPT_pedantic:
885 cpp_opts->pedantic = 1;
886 cpp_opts->warn_endif_labels = 1;
887 /* (TIGCC 20050217) No Microsoft extensions if -pedantic. */
888 flag_ms_extensions = 0;
889 if (warn_pointer_sign == -1)
890 warn_pointer_sign = 1;
891 break;
892
893 case OPT_print_objc_runtime_info:
894 print_struct_values = 1;
895 break;
896
897 case OPT_print_pch_checksum:
898 c_common_print_pch_checksum (stdout);
899 exit_after_options = true;
900 break;
901
902 case OPT_remap:
903 cpp_opts->remap = 1;
904 break;
905
906 case OPT_std_c__98:
907 case OPT_std_gnu__98:
908 set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
909 break;
910
911 case OPT_std_c89:
912 case OPT_std_iso9899_1990:
913 case OPT_std_iso9899_199409:
914 set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
915 break;
916
917 case OPT_std_gnu89:
918 set_std_c89 (false /* c94 */, false /* ISO */);
919 break;
920
921 case OPT_std_c99:
922 case OPT_std_c9x:
923 case OPT_std_iso9899_1999:
924 case OPT_std_iso9899_199x:
925 set_std_c99 (true /* ISO */);
926 break;
927
928 case OPT_std_gnu99:
929 case OPT_std_gnu9x:
930 set_std_c99 (false /* ISO */);
931 break;
932
933 case OPT_trigraphs:
934 cpp_opts->trigraphs = 1;
935 break;
936
937 case OPT_traditional_cpp:
938 cpp_opts->traditional = 1;
939 break;
940
941 case OPT_undef:
942 flag_undef = 1;
943 break;
944
945 case OPT_w:
946 cpp_opts->inhibit_warnings = 1;
947 break;
948
949 case OPT_v:
950 verbose = true;
951 break;
952
953 case OPT_fauto_octals:
954 cpp_opts->no_auto_octals = !value;
955 break;
956 }
957
958 return result;
959 }
960
961 /* Post-switch processing. */
962 bool
c_common_post_options(const char ** pfilename)963 c_common_post_options (const char **pfilename)
964 {
965 struct cpp_callbacks *cb;
966
967 /* Canonicalize the input and output filenames. */
968 if (in_fnames == NULL)
969 {
970 in_fnames = XNEWVEC (const char *, 1);
971 in_fnames[0] = "";
972 }
973 else if (strcmp (in_fnames[0], "-") == 0)
974 in_fnames[0] = "";
975
976 if (out_fname == NULL || !strcmp (out_fname, "-"))
977 out_fname = "";
978
979 if (cpp_opts->deps.style == DEPS_NONE)
980 check_deps_environment_vars ();
981
982 handle_deferred_opts ();
983
984 sanitize_cpp_opts ();
985
986 register_include_chains (parse_in, sysroot, iprefix,
987 std_inc, std_cxx_inc && c_dialect_cxx (), verbose);
988
989 flag_inline_trees = 1;
990
991 /* Use tree inlining. */
992 if (!flag_no_inline)
993 flag_no_inline = 1;
994 if (flag_inline_functions)
995 flag_inline_trees = 2;
996
997 /* If we are given more than one input file, we must use
998 unit-at-a-time mode. */
999 if (num_in_fnames > 1)
1000 flag_unit_at_a_time = 1;
1001
1002 /* Default to ObjC sjlj exception handling if NeXT runtime. */
1003 if (flag_objc_sjlj_exceptions < 0)
1004 flag_objc_sjlj_exceptions = flag_next_runtime;
1005 if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
1006 flag_exceptions = 1;
1007
1008 /* -Wextra implies -Wsign-compare and -Wmissing-field-initializers,
1009 but not if explicitly overridden. */
1010 if (warn_sign_compare == -1)
1011 warn_sign_compare = extra_warnings;
1012 if (warn_missing_field_initializers == -1)
1013 warn_missing_field_initializers = extra_warnings;
1014
1015 /* -Wpointer_sign is disabled by default, but it is enabled if any
1016 of -Wall or -pedantic are given. */
1017 if (warn_pointer_sign == -1)
1018 warn_pointer_sign = 0;
1019
1020 /* Special format checking options don't work without -Wformat; warn if
1021 they are used. */
1022 if (!warn_format)
1023 {
1024 warning (OPT_Wformat_y2k,
1025 "-Wformat-y2k ignored without -Wformat");
1026 warning (OPT_Wformat_extra_args,
1027 "-Wformat-extra-args ignored without -Wformat");
1028 warning (OPT_Wformat_zero_length,
1029 "-Wformat-zero-length ignored without -Wformat");
1030 warning (OPT_Wformat_nonliteral,
1031 "-Wformat-nonliteral ignored without -Wformat");
1032 warning (OPT_Wformat_security,
1033 "-Wformat-security ignored without -Wformat");
1034 }
1035
1036 #if 0 /* (TIGCC 20050306) Disable as we don't have these libcalls. */
1037 /* C99 requires special handling of complex multiplication and division;
1038 -ffast-math and -fcx-limited-range are handled in process_options. */
1039 if (flag_isoc99)
1040 flag_complex_method = 2;
1041 #endif /* 0 */
1042
1043 if (flag_preprocess_only)
1044 {
1045 /* Open the output now. We must do so even if flag_no_output is
1046 on, because there may be other output than from the actual
1047 preprocessing (e.g. from -dM). */
1048 if (out_fname[0] == '\0')
1049 out_stream = stdout;
1050 else
1051 out_stream = fopen (out_fname, "w");
1052
1053 if (out_stream == NULL)
1054 {
1055 fatal_error ("opening output file %s: %m", out_fname);
1056 return false;
1057 }
1058
1059 if (num_in_fnames > 1)
1060 error ("too many filenames given. Type %s --help for usage",
1061 progname);
1062
1063 init_pp_output (out_stream);
1064 }
1065 else
1066 {
1067 init_c_lex ();
1068
1069 /* Yuk. WTF is this? I do know ObjC relies on it somewhere. */
1070 input_location = UNKNOWN_LOCATION;
1071 }
1072
1073 cb = cpp_get_callbacks (parse_in);
1074 cb->file_change = cb_file_change;
1075 cb->dir_change = cb_dir_change;
1076 cpp_post_options (parse_in);
1077
1078 input_location = UNKNOWN_LOCATION;
1079
1080 /* If an error has occurred in cpplib, note it so we fail
1081 immediately. */
1082 errorcount += cpp_errors (parse_in);
1083
1084 *pfilename = this_input_filename
1085 = cpp_read_main_file (parse_in, in_fnames[0]);
1086 /* Don't do any compilation or preprocessing if there is no input file. */
1087 if (this_input_filename == NULL)
1088 {
1089 errorcount++;
1090 return false;
1091 }
1092
1093 if (flag_working_directory
1094 && flag_preprocess_only && !flag_no_line_commands)
1095 pp_dir_change (parse_in, get_src_pwd ());
1096
1097 return flag_preprocess_only;
1098 }
1099
1100 /* Front end initialization common to C, ObjC and C++. */
1101 bool
c_common_init(void)1102 c_common_init (void)
1103 {
1104 /* Set up preprocessor arithmetic. Must be done after call to
1105 c_common_nodes_and_builtins for type nodes to be good. */
1106 cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1107 cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1108 cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1109 cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1110 cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
1111 cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
1112
1113 /* This can't happen until after wchar_precision and bytes_big_endian
1114 are known. */
1115 cpp_init_iconv (parse_in);
1116
1117 if (version_flag)
1118 c_common_print_pch_checksum (stderr);
1119
1120 if (flag_preprocess_only)
1121 {
1122 finish_options ();
1123 preprocess_file (parse_in);
1124 return false;
1125 }
1126
1127 /* Has to wait until now so that cpplib has its hash table. */
1128 init_pragma ();
1129
1130 return true;
1131 }
1132
1133 /* Initialize the integrated preprocessor after debug output has been
1134 initialized; loop over each input file. */
1135 void
c_common_parse_file(int set_yydebug)1136 c_common_parse_file (int set_yydebug)
1137 {
1138 unsigned int i;
1139
1140 /* Enable parser debugging, if requested and we can. If requested
1141 and we can't, notify the user. */
1142 #if YYDEBUG != 0
1143 yydebug = set_yydebug;
1144 #else
1145 if (set_yydebug)
1146 warning (0, "YYDEBUG was not defined at build time, -dy ignored");
1147 #endif
1148
1149 i = 0;
1150 for (;;)
1151 {
1152 /* Start the main input file, if the debug writer wants it. */
1153 if (debug_hooks->start_end_main_source_file)
1154 (*debug_hooks->start_source_file) (0, this_input_filename);
1155 finish_options ();
1156 pch_init ();
1157 push_file_scope ();
1158 c_parse_file ();
1159 finish_file ();
1160 pop_file_scope ();
1161 /* And end the main input file, if the debug writer wants it */
1162 if (debug_hooks->start_end_main_source_file)
1163 (*debug_hooks->end_source_file) (0);
1164 if (++i >= num_in_fnames)
1165 break;
1166 cpp_undef_all (parse_in);
1167 this_input_filename
1168 = cpp_read_main_file (parse_in, in_fnames[i]);
1169 /* If an input file is missing, abandon further compilation.
1170 cpplib has issued a diagnostic. */
1171 if (!this_input_filename)
1172 break;
1173 }
1174 }
1175
1176 /* Common finish hook for the C, ObjC and C++ front ends. */
1177 void
c_common_finish(void)1178 c_common_finish (void)
1179 {
1180 FILE *deps_stream = NULL;
1181
1182 if (cpp_opts->deps.style != DEPS_NONE)
1183 {
1184 /* If -M or -MM was seen without -MF, default output to the
1185 output stream. */
1186 if (!deps_file)
1187 deps_stream = out_stream;
1188 else
1189 {
1190 deps_stream = fopen (deps_file, deps_append ? "a": "w");
1191 if (!deps_stream)
1192 fatal_error ("opening dependency file %s: %m", deps_file);
1193 }
1194 }
1195
1196 /* For performance, avoid tearing down cpplib's internal structures
1197 with cpp_destroy (). */
1198 errorcount += cpp_finish (parse_in, deps_stream);
1199
1200 if (deps_stream && deps_stream != out_stream
1201 && (ferror (deps_stream) || fclose (deps_stream)))
1202 fatal_error ("closing dependency file %s: %m", deps_file);
1203
1204 if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1205 fatal_error ("when writing output to %s: %m", out_fname);
1206 }
1207
1208 /* Either of two environment variables can specify output of
1209 dependencies. Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1210 DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1211 and DEPS_TARGET is the target to mention in the deps. They also
1212 result in dependency information being appended to the output file
1213 rather than overwriting it, and like Sun's compiler
1214 SUNPRO_DEPENDENCIES suppresses the dependency on the main file. */
1215 static void
check_deps_environment_vars(void)1216 check_deps_environment_vars (void)
1217 {
1218 char *spec;
1219
1220 GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1221 if (spec)
1222 cpp_opts->deps.style = DEPS_USER;
1223 else
1224 {
1225 GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1226 if (spec)
1227 {
1228 cpp_opts->deps.style = DEPS_SYSTEM;
1229 cpp_opts->deps.ignore_main_file = true;
1230 }
1231 }
1232
1233 if (spec)
1234 {
1235 /* Find the space before the DEPS_TARGET, if there is one. */
1236 char *s = strchr (spec, ' ');
1237 if (s)
1238 {
1239 /* Let the caller perform MAKE quoting. */
1240 defer_opt (OPT_MT, s + 1);
1241 *s = '\0';
1242 }
1243
1244 /* Command line -MF overrides environment variables and default. */
1245 if (!deps_file)
1246 deps_file = spec;
1247
1248 deps_append = 1;
1249 deps_seen = true;
1250 }
1251 }
1252
1253 /* Handle deferred command line switches. */
1254 static void
handle_deferred_opts(void)1255 handle_deferred_opts (void)
1256 {
1257 size_t i;
1258 struct deps *deps;
1259
1260 /* Avoid allocating the deps buffer if we don't need it.
1261 (This flag may be true without there having been -MT or -MQ
1262 options, but we'll still need the deps buffer.) */
1263 if (!deps_seen)
1264 return;
1265
1266 deps = cpp_get_deps (parse_in);
1267
1268 for (i = 0; i < deferred_count; i++)
1269 {
1270 struct deferred_opt *opt = &deferred_opts[i];
1271
1272 if (opt->code == OPT_MT || opt->code == OPT_MQ)
1273 deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
1274 }
1275 }
1276
1277 /* These settings are appropriate for GCC, but not necessarily so for
1278 cpplib as a library. */
1279 static void
sanitize_cpp_opts(void)1280 sanitize_cpp_opts (void)
1281 {
1282 /* If we don't know what style of dependencies to output, complain
1283 if any other dependency switches have been given. */
1284 if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1285 error ("to generate dependencies you must specify either -M or -MM");
1286
1287 /* -dM and dependencies suppress normal output; do it here so that
1288 the last -d[MDN] switch overrides earlier ones. */
1289 if (flag_dump_macros == 'M')
1290 flag_no_output = 1;
1291
1292 /* Disable -dD, -dN and -dI if normal output is suppressed. Allow
1293 -dM since at least glibc relies on -M -dM to work. */
1294 /* Also, flag_no_output implies flag_no_line_commands, always. */
1295 if (flag_no_output)
1296 {
1297 if (flag_dump_macros != 'M')
1298 flag_dump_macros = 0;
1299 flag_dump_includes = 0;
1300 flag_no_line_commands = 1;
1301 }
1302
1303 cpp_opts->unsigned_char = !flag_signed_char;
1304 cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1305
1306 /* We want -Wno-long-long to override -pedantic -std=non-c99
1307 and/or -Wtraditional, whatever the ordering. */
1308 cpp_opts->warn_long_long
1309 = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
1310
1311 /* Similarly with -Wno-variadic-macros. No check for c99 here, since
1312 this also turns off warnings about GCCs extension. */
1313 cpp_opts->warn_variadic_macros
1314 = warn_variadic_macros && (pedantic || warn_traditional);
1315
1316 /* If we're generating preprocessor output, emit current directory
1317 if explicitly requested or if debugging information is enabled.
1318 ??? Maybe we should only do it for debugging formats that
1319 actually output the current directory? */
1320 if (flag_working_directory == -1)
1321 flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1322 }
1323
1324 /* Add include path with a prefix at the front of its name. */
1325 static void
add_prefixed_path(const char * suffix,size_t chain)1326 add_prefixed_path (const char *suffix, size_t chain)
1327 {
1328 char *path;
1329 const char *prefix;
1330 size_t prefix_len, suffix_len;
1331
1332 suffix_len = strlen (suffix);
1333 prefix = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
1334 prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
1335
1336 path = (char *) xmalloc (prefix_len + suffix_len + 1);
1337 memcpy (path, prefix, prefix_len);
1338 memcpy (path + prefix_len, suffix, suffix_len);
1339 path[prefix_len + suffix_len] = '\0';
1340
1341 add_path (path, chain, 0, false);
1342 }
1343
1344 /* Handle -D, -U, -A, -imacros, and the first -include. */
1345 static void
finish_options(void)1346 finish_options (void)
1347 {
1348 if (!cpp_opts->preprocessed)
1349 {
1350 size_t i;
1351
1352 cb_file_change (parse_in,
1353 linemap_add (&line_table, LC_RENAME, 0,
1354 _("<built-in>"), 0));
1355
1356 cpp_init_builtins (parse_in, flag_hosted);
1357 c_cpp_builtins (parse_in);
1358
1359 /* We're about to send user input to cpplib, so make it warn for
1360 things that we previously (when we sent it internal definitions)
1361 told it to not warn.
1362
1363 C99 permits implementation-defined characters in identifiers.
1364 The documented meaning of -std= is to turn off extensions that
1365 conflict with the specified standard, and since a strictly
1366 conforming program cannot contain a '$', we do not condition
1367 their acceptance on the -std= setting. */
1368 cpp_opts->warn_dollars = (cpp_opts->pedantic && !cpp_opts->c99);
1369
1370 cpp_change_file (parse_in, LC_RENAME, _("<command line>"));
1371 for (i = 0; i < deferred_count; i++)
1372 {
1373 struct deferred_opt *opt = &deferred_opts[i];
1374
1375 if (opt->code == OPT_D)
1376 cpp_define (parse_in, opt->arg);
1377 else if (opt->code == OPT_U)
1378 cpp_undef (parse_in, opt->arg);
1379 else if (opt->code == OPT_A)
1380 {
1381 if (opt->arg[0] == '-')
1382 cpp_unassert (parse_in, opt->arg + 1);
1383 else
1384 cpp_assert (parse_in, opt->arg);
1385 }
1386 }
1387
1388 /* Handle -imacros after -D and -U. */
1389 for (i = 0; i < deferred_count; i++)
1390 {
1391 struct deferred_opt *opt = &deferred_opts[i];
1392
1393 if (opt->code == OPT_imacros
1394 && cpp_push_include (parse_in, opt->arg))
1395 {
1396 /* Disable push_command_line_include callback for now. */
1397 include_cursor = deferred_count + 1;
1398 cpp_scan_nooutput (parse_in);
1399 }
1400 }
1401 }
1402
1403 include_cursor = 0;
1404 push_command_line_include ();
1405 }
1406
1407 /* Give CPP the next file given by -include, if any. */
1408 static void
push_command_line_include(void)1409 push_command_line_include (void)
1410 {
1411 while (include_cursor < deferred_count)
1412 {
1413 struct deferred_opt *opt = &deferred_opts[include_cursor++];
1414
1415 if (!cpp_opts->preprocessed && opt->code == OPT_include
1416 && cpp_push_include (parse_in, opt->arg))
1417 return;
1418 }
1419
1420 if (include_cursor == deferred_count)
1421 {
1422 include_cursor++;
1423 /* -Wunused-macros should only warn about macros defined hereafter. */
1424 cpp_opts->warn_unused_macros = warn_unused_macros;
1425 /* Restore the line map from <command line>. */
1426 if (!cpp_opts->preprocessed)
1427 cpp_change_file (parse_in, LC_RENAME, this_input_filename);
1428
1429 /* Set this here so the client can change the option if it wishes,
1430 and after stacking the main file so we don't trace the main file. */
1431 line_table.trace_includes = cpp_opts->print_include_names;
1432 }
1433 }
1434
1435 /* File change callback. Has to handle -include files. */
1436 static void
cb_file_change(cpp_reader * ARG_UNUSED (pfile),const struct line_map * new_map)1437 cb_file_change (cpp_reader * ARG_UNUSED (pfile),
1438 const struct line_map *new_map)
1439 {
1440 if (flag_preprocess_only)
1441 pp_file_change (new_map);
1442 else
1443 fe_file_change (new_map);
1444
1445 if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1446 push_command_line_include ();
1447 }
1448
1449 void
cb_dir_change(cpp_reader * ARG_UNUSED (pfile),const char * dir)1450 cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
1451 {
1452 if (!set_src_pwd (dir))
1453 warning (0, "too late for # directive to set debug directory");
1454 }
1455
1456 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1457 extensions if ISO). There is no concept of gnu94. */
1458 static void
set_std_c89(int c94,int iso)1459 set_std_c89 (int c94, int iso)
1460 {
1461 cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1462 flag_iso = iso;
1463 flag_no_asm = iso;
1464 flag_no_gnu_keywords = iso;
1465 flag_no_nonansi_builtin = iso;
1466 flag_isoc94 = c94;
1467 flag_isoc99 = 0;
1468 }
1469
1470 /* Set the C 99 standard (without GNU extensions if ISO). */
1471 static void
set_std_c99(int iso)1472 set_std_c99 (int iso)
1473 {
1474 cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1475 flag_no_asm = iso;
1476 flag_no_nonansi_builtin = iso;
1477 flag_iso = iso;
1478 flag_isoc99 = 1;
1479 flag_isoc94 = 1;
1480 }
1481
1482 /* Set the C++ 98 standard (without GNU extensions if ISO). */
1483 static void
set_std_cxx98(int iso)1484 set_std_cxx98 (int iso)
1485 {
1486 cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1487 flag_no_gnu_keywords = iso;
1488 flag_no_nonansi_builtin = iso;
1489 flag_iso = iso;
1490 }
1491
1492 /* Handle setting implicit to ON. */
1493 static void
set_Wimplicit(int on)1494 set_Wimplicit (int on)
1495 {
1496 warn_implicit = on;
1497 warn_implicit_int = on;
1498 if (on)
1499 {
1500 if (mesg_implicit_function_declaration != 2)
1501 mesg_implicit_function_declaration = 1;
1502 }
1503 else
1504 mesg_implicit_function_declaration = 0;
1505 }
1506
1507 /* Args to -d specify what to dump. Silently ignore
1508 unrecognized options; they may be aimed at toplev.c. */
1509 static void
handle_OPT_d(const char * arg)1510 handle_OPT_d (const char *arg)
1511 {
1512 char c;
1513
1514 while ((c = *arg++) != '\0')
1515 switch (c)
1516 {
1517 case 'M': /* Dump macros only. */
1518 case 'N': /* Dump names. */
1519 case 'D': /* Dump definitions. */
1520 flag_dump_macros = c;
1521 break;
1522
1523 case 'I':
1524 flag_dump_includes = 1;
1525 break;
1526 }
1527 }
1528