?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ifcvt.c (noce_try_addcc): Do not call emit_conditional_add with weird operands.
[official-gcc.git] / gcc / c-opts.c
blob5270d625a20654fad4588798cecbba7cd44da446
1 /* C/ObjC/C++ command line option handling.
2 Copyright (C) 2002 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, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, 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
36 /* CPP's options. */
37 static cpp_options *cpp_opts;
38
39 /* Input filename. */
40 static const char *in_fname;
41
42 /* Filename and stream for preprocessed output. */
43 static const char *out_fname;
44 static FILE *out_stream;
45
46 /* Append dependencies to deps_file. */
47 static bool deps_append;
48
49 /* If dependency switches (-MF etc.) have been given. */
50 static bool deps_seen;
51
52 /* Dependency output file. */
53 static const char *deps_file;
54
55 /* Number of deferred options, deferred options array size. */
56 static size_t deferred_count, deferred_size;
57
58 static void missing_arg PARAMS ((size_t));
59 static size_t find_opt PARAMS ((const char *, int));
60 static void set_Wimplicit PARAMS ((int));
61 static void complain_wrong_lang PARAMS ((size_t));
62 static void write_langs PARAMS ((char *, int));
63 static void print_help PARAMS ((void));
64 static void handle_OPT_d PARAMS ((const char *));
65 static void set_std_cxx98 PARAMS ((int));
66 static void set_std_c89 PARAMS ((int, int));
67 static void set_std_c99 PARAMS ((int));
68 static void check_deps_environment_vars PARAMS ((void));
69 static void preprocess_file PARAMS ((void));
70 static void handle_deferred_opts PARAMS ((void));
71 static void sanitize_cpp_opts PARAMS ((void));
72
73 #ifndef STDC_0_IN_SYSTEM_HEADERS
74 #define STDC_0_IN_SYSTEM_HEADERS 0
75 #endif
76
77 #define CL_C_ONLY (1 << 0) /* Only C. */
78 #define CL_OBJC_ONLY (1 << 1) /* Only ObjC. */
79 #define CL_CXX_ONLY (1 << 2) /* Only C++. */
80 #define CL_OBJCXX_ONLY (1 << 3) /* Only ObjC++. */
81 #define CL_JOINED (1 << 4) /* If takes joined argument. */
82 #define CL_SEPARATE (1 << 5) /* If takes a separate argument. */
83
84 #define CL_ARG (CL_JOINED | CL_SEPARATE)
85 #define CL_C (CL_C_ONLY | CL_OBJC_ONLY)
86 #define CL_OBJC (CL_OBJC_ONLY | CL_OBJCXX_ONLY)
87 #define CL_CXX (CL_CXX_ONLY | CL_OBJCXX_ONLY)
88 #define CL_ALL (CL_C | CL_CXX)
89
90 /* This is the list of all command line options, with the leading "-"
91 removed. It must be sorted in ASCII collating order. All options
92 beginning with "f" or "W" are implicitly assumed to take a "no-"
93 form; this form should not be listed. The variable "on" is true if
94 the positive form is given, otherwise it is false. If you don't
95 want to allow a "no-" form, your handler should reject "on" being
96 false by returning zero. See, for example, the handling of
97 -ftabstop=.
98
99 If the user gives an option to a front end that doesn't support it,
100 an error is output, mentioning which front ends the option is valid
101 for. If you don't want this, you must accept it for all front
102 ends, and test for the front end in the option handler. See, for
103 example, the handling of -Wno-strict-prototypes for C++.
104
105 If you request an argument with CL_JOINED, CL_SEPARATE or their
106 combination CL_ARG, it is stored in the variable "arg", which is
107 guaranteed to be non-NULL and to not be an empty string. It points
108 to the argument either within the argv[] vector or within one of
109 that vector's strings, and so the text is permanent and copies need
110 not be made. Be sure to add an error message in missing_arg() if
111 the default is not appropriate. */
112
113 #define COMMAND_LINE_OPTIONS \
114 OPT("-help", CL_ALL, OPT__help) \
115 OPT("-output-pch=", CL_ALL | CL_ARG, OPT__output_pch) \
116 OPT("C", CL_ALL, OPT_C) \
117 OPT("CC", CL_ALL, OPT_CC) \
118 OPT("E", CL_ALL, OPT_E) \
119 OPT("H", CL_ALL, OPT_H) \
120 OPT("M", CL_ALL, OPT_M) \
121 OPT("MD", CL_ALL | CL_SEPARATE, OPT_MD) \
122 OPT("MF", CL_ALL | CL_ARG, OPT_MF) \
123 OPT("MG", CL_ALL, OPT_MG) \
124 OPT("MM", CL_ALL, OPT_MM) \
125 OPT("MMD", CL_ALL | CL_SEPARATE, OPT_MMD) \
126 OPT("MP", CL_ALL, OPT_MP) \
127 OPT("MQ", CL_ALL | CL_ARG, OPT_MQ) \
128 OPT("MT", CL_ALL | CL_ARG, OPT_MT) \
129 OPT("P", CL_ALL, OPT_P) \
130 OPT("Wabi", CL_CXX, OPT_Wabi) \
131 OPT("Wall", CL_ALL, OPT_Wall) \
132 OPT("Wbad-function-cast", CL_C, OPT_Wbad_function_cast) \
133 OPT("Wcast-qual", CL_ALL, OPT_Wcast_qual) \
134 OPT("Wchar-subscripts", CL_ALL, OPT_Wchar_subscripts) \
135 OPT("Wcomment", CL_ALL, OPT_Wcomment) \
136 OPT("Wcomments", CL_ALL, OPT_Wcomments) \
137 OPT("Wconversion", CL_ALL, OPT_Wconversion) \
138 OPT("Wctor-dtor-privacy", CL_CXX, OPT_Wctor_dtor_privacy) \
139 OPT("Wdeprecated", CL_CXX, OPT_Wdeprecated) \
140 OPT("Wdiv-by-zero", CL_C, OPT_Wdiv_by_zero) \
141 OPT("Weffc++", CL_CXX, OPT_Weffcxx) \
142 OPT("Wendif-labels", CL_ALL, OPT_Wendif_labels) \
143 OPT("Werror", CL_ALL, OPT_Werror) \
144 OPT("Werror-implicit-function-declaration", \
145 CL_C, OPT_Werror_implicit_function_decl) \
146 OPT("Wfloat-equal", CL_ALL, OPT_Wfloat_equal) \
147 OPT("Wformat", CL_ALL, OPT_Wformat) \
148 OPT("Wformat-extra-args", CL_ALL, OPT_Wformat_extra_args) \
149 OPT("Wformat-nonliteral", CL_ALL, OPT_Wformat_nonliteral) \
150 OPT("Wformat-security", CL_ALL, OPT_Wformat_security) \
151 OPT("Wformat-y2k", CL_ALL, OPT_Wformat_y2k) \
152 OPT("Wformat-zero-length", CL_C, OPT_Wformat_zero_length) \
153 OPT("Wformat=", CL_ALL | CL_JOINED, OPT_Wformat_eq) \
154 OPT("Wimplicit", CL_ALL, OPT_Wimplicit) \
155 OPT("Wimplicit-function-declaration", CL_C, OPT_Wimplicit_function_decl) \
156 OPT("Wimplicit-int", CL_C, OPT_Wimplicit_int) \
157 OPT("Wimport", CL_ALL, OPT_Wimport) \
158 OPT("Winvalid-pch", CL_ALL, OPT_Winvalid_pch) \
159 OPT("Wlong-long", CL_ALL, OPT_Wlong_long) \
160 OPT("Wmain", CL_C, OPT_Wmain) \
161 OPT("Wmissing-braces", CL_ALL, OPT_Wmissing_braces) \
162 OPT("Wmissing-declarations", CL_C, OPT_Wmissing_declarations) \
163 OPT("Wmissing-format-attribute",CL_ALL, OPT_Wmissing_format_attribute) \
164 OPT("Wmissing-prototypes", CL_ALL, OPT_Wmissing_prototypes) \
165 OPT("Wmultichar", CL_ALL, OPT_Wmultichar) \
166 OPT("Wnested-externs", CL_C, OPT_Wnested_externs) \
167 OPT("Wnon-template-friend", CL_CXX, OPT_Wnon_template_friend) \
168 OPT("Wnon-virtual-dtor", CL_CXX, OPT_Wnon_virtual_dtor) \
169 OPT("Wnonnull", CL_C, OPT_Wnonnull) \
170 OPT("Wold-style-cast", CL_CXX, OPT_Wold_style_cast) \
171 OPT("Woverloaded-virtual", CL_CXX, OPT_Woverloaded_virtual) \
172 OPT("Wparentheses", CL_ALL, OPT_Wparentheses) \
173 OPT("Wpmf-conversions", CL_CXX, OPT_Wpmf_conversions) \
174 OPT("Wpointer-arith", CL_ALL, OPT_Wpointer_arith) \
175 OPT("Wprotocol", CL_OBJC, OPT_Wprotocol) \
176 OPT("Wredundant-decls", CL_ALL, OPT_Wredundant_decls) \
177 OPT("Wreorder", CL_CXX, OPT_Wreorder) \
178 OPT("Wreturn-type", CL_ALL, OPT_Wreturn_type) \
179 OPT("Wselector", CL_OBJC, OPT_Wselector) \
180 OPT("Wsequence-point", CL_C, OPT_Wsequence_point) \
181 OPT("Wsign-compare", CL_ALL, OPT_Wsign_compare) \
182 OPT("Wsign-promo", CL_CXX, OPT_Wsign_promo) \
183 OPT("Wstrict-prototypes", CL_ALL, OPT_Wstrict_prototypes) \
184 OPT("Wsynth", CL_CXX, OPT_Wsynth) \
185 OPT("Wsystem-headers", CL_ALL, OPT_Wsystem_headers) \
186 OPT("Wtraditional", CL_C, OPT_Wtraditional) \
187 OPT("Wtrigraphs", CL_ALL, OPT_Wtrigraphs) \
188 OPT("Wundeclared-selector", CL_OBJC, OPT_Wundeclared_selector) \
189 OPT("Wundef", CL_ALL, OPT_Wundef) \
190 OPT("Wunknown-pragmas", CL_ALL, OPT_Wunknown_pragmas) \
191 OPT("Wunused-macros", CL_ALL, OPT_Wunused_macros) \
192 OPT("Wwrite-strings", CL_ALL, OPT_Wwrite_strings) \
193 OPT("ansi", CL_ALL, OPT_ansi) \
194 OPT("d", CL_ALL | CL_JOINED, OPT_d) \
195 OPT("fabi-version=", CL_CXX | CL_JOINED, OPT_fabi_version) \
196 OPT("faccess-control", CL_CXX, OPT_faccess_control) \
197 OPT("fall-virtual", CL_CXX, OPT_fall_virtual) \
198 OPT("falt-external-templates",CL_CXX, OPT_falt_external_templates) \
199 OPT("fasm", CL_ALL, OPT_fasm) \
200 OPT("fbuiltin", CL_ALL, OPT_fbuiltin) \
201 OPT("fbuiltin-", CL_ALL | CL_JOINED, OPT_fbuiltin_) \
202 OPT("fcheck-new", CL_CXX, OPT_fcheck_new) \
203 OPT("fcond-mismatch", CL_ALL, OPT_fcond_mismatch) \
204 OPT("fconserve-space", CL_CXX, OPT_fconserve_space) \
205 OPT("fconst-strings", CL_CXX, OPT_fconst_strings) \
206 OPT("fconstant-string-class=", CL_OBJC | CL_JOINED, \
207 OPT_fconstant_string_class) \
208 OPT("fdefault-inline", CL_CXX, OPT_fdefault_inline) \
209 OPT("fdollars-in-identifiers",CL_ALL, OPT_fdollars_in_identifiers) \
210 OPT("fdump-", CL_ALL | CL_JOINED, OPT_fdump) \
211 OPT("felide-constructors", CL_CXX, OPT_felide_constructors) \
212 OPT("fenforce-eh-specs", CL_CXX, OPT_fenforce_eh_specs) \
213 OPT("fenum-int-equiv", CL_CXX, OPT_fenum_int_equiv) \
214 OPT("fexternal-templates", CL_CXX, OPT_fexternal_templates) \
215 OPT("ffor-scope", CL_CXX, OPT_ffor_scope) \
216 OPT("ffreestanding", CL_C, OPT_ffreestanding) \
217 OPT("fgnu-keywords", CL_CXX, OPT_fgnu_keywords) \
218 OPT("fgnu-runtime", CL_OBJC, OPT_fgnu_runtime) \
219 OPT("fguiding-decls", CL_CXX, OPT_fguiding_decls) \
220 OPT("fhandle-exceptions", CL_CXX, OPT_fhandle_exceptions) \
221 OPT("fhonor-std", CL_CXX, OPT_fhonor_std) \
222 OPT("fhosted", CL_C, OPT_fhosted) \
223 OPT("fhuge-objects", CL_CXX, OPT_fhuge_objects) \
224 OPT("fimplement-inlines", CL_CXX, OPT_fimplement_inlines) \
225 OPT("fimplicit-inline-templates", CL_CXX, OPT_fimplicit_inline_templates) \
226 OPT("fimplicit-templates", CL_CXX, OPT_fimplicit_templates) \
227 OPT("flabels-ok", CL_CXX, OPT_flabels_ok) \
228 OPT("fms-extensions", CL_ALL, OPT_fms_extensions) \
229 OPT("fname-mangling-version-",CL_CXX | CL_JOINED, OPT_fname_mangling) \
230 OPT("fnew-abi", CL_CXX, OPT_fnew_abi) \
231 OPT("fnext-runtime", CL_OBJC, OPT_fnext_runtime) \
232 OPT("fnonansi-builtins", CL_CXX, OPT_fnonansi_builtins) \
233 OPT("fnonnull-objects", CL_CXX, OPT_fnonnull_objects) \
234 OPT("foperator-names", CL_CXX, OPT_foperator_names) \
235 OPT("foptional-diags", CL_CXX, OPT_foptional_diags) \
236 OPT("fpch-deps", CL_ALL, OPT_fpch_deps) \
237 OPT("fpermissive", CL_CXX, OPT_fpermissive) \
238 OPT("fpreprocessed", CL_ALL, OPT_fpreprocessed) \
239 OPT("frepo", CL_CXX, OPT_frepo) \
240 OPT("frtti", CL_CXX, OPT_frtti) \
241 OPT("fshort-double", CL_ALL, OPT_fshort_double) \
242 OPT("fshort-enums", CL_ALL, OPT_fshort_enums) \
243 OPT("fshort-wchar", CL_ALL, OPT_fshort_wchar) \
244 OPT("fshow-column", CL_ALL, OPT_fshow_column) \
245 OPT("fsigned-bitfields", CL_ALL, OPT_fsigned_bitfields) \
246 OPT("fsigned-char", CL_ALL, OPT_fsigned_char) \
247 OPT("fsquangle", CL_CXX, OPT_fsquangle) \
248 OPT("fstats", CL_CXX, OPT_fstats) \
249 OPT("fstrict-prototype", CL_CXX, OPT_fstrict_prototype) \
250 OPT("ftabstop=", CL_ALL | CL_JOINED, OPT_ftabstop) \
251 OPT("ftemplate-depth-", CL_CXX | CL_JOINED, OPT_ftemplate_depth) \
252 OPT("fthis-is-variable", CL_CXX, OPT_fthis_is_variable) \
253 OPT("funsigned-bitfields", CL_ALL, OPT_funsigned_bitfields) \
254 OPT("funsigned-char", CL_ALL, OPT_funsigned_char) \
255 OPT("fuse-cxa-atexit", CL_CXX, OPT_fuse_cxa_atexit) \
256 OPT("fvtable-gc", CL_CXX, OPT_fvtable_gc) \
257 OPT("fvtable-thunks", CL_CXX, OPT_fvtable_thunks) \
258 OPT("fweak", CL_CXX, OPT_fweak) \
259 OPT("fxref", CL_CXX, OPT_fxref) \
260 OPT("gen-decls", CL_OBJC, OPT_gen_decls) \
261 OPT("lang-asm", CL_C_ONLY, OPT_lang_asm) \
262 OPT("lang-objc", CL_ALL, OPT_lang_objc) \
263 OPT("nostdinc", CL_ALL, OPT_nostdinc) \
264 OPT("nostdinc++", CL_ALL, OPT_nostdincplusplus) \
265 OPT("o", CL_ALL | CL_ARG, OPT_o) \
266 OPT("pedantic", CL_ALL, OPT_pedantic) \
267 OPT("pedantic-errors", CL_ALL, OPT_pedantic_errors) \
268 OPT("print-objc-runtime-info", CL_OBJC, OPT_print_objc_runtime_info) \
269 OPT("remap", CL_ALL, OPT_remap) \
270 OPT("std=c++98", CL_CXX, OPT_std_cplusplus98) \
271 OPT("std=c89", CL_C, OPT_std_c89) \
272 OPT("std=c99", CL_C, OPT_std_c99) \
273 OPT("std=c9x", CL_C, OPT_std_c9x) \
274 OPT("std=gnu++98", CL_CXX, OPT_std_gnuplusplus98) \
275 OPT("std=gnu89", CL_C, OPT_std_gnu89) \
276 OPT("std=gnu99", CL_C, OPT_std_gnu99) \
277 OPT("std=gnu9x", CL_C, OPT_std_gnu9x) \
278 OPT("std=iso9899:1990", CL_C, OPT_std_iso9899_1990) \
279 OPT("std=iso9899:199409", CL_C, OPT_std_iso9899_199409) \
280 OPT("std=iso9899:1999", CL_C, OPT_std_iso9899_1999) \
281 OPT("std=iso9899:199x", CL_C, OPT_std_iso9899_199x) \
282 OPT("traditional-cpp", CL_ALL, OPT_traditional_cpp) \
283 OPT("trigraphs", CL_ALL, OPT_trigraphs) \
284 OPT("undef", CL_ALL, OPT_undef) \
285 OPT("v", CL_ALL, OPT_v) \
286 OPT("w", CL_ALL, OPT_w)
287
288 #define OPT(text, flags, code) code,
289 enum opt_code
290 {
291 COMMAND_LINE_OPTIONS
292 N_OPTS
293 };
294 #undef OPT
295
296 struct cl_option
297 {
298 const char *opt_text;
299 unsigned char opt_len;
300 unsigned char flags;
301 ENUM_BITFIELD (opt_code) opt_code : 2 * CHAR_BIT;
302 };
303
304 #define OPT(text, flags, code) { text, sizeof(text) - 1, flags, code },
305 #ifdef HOST_EBCDIC
306 static struct cl_option cl_options[] =
307 #else
308 static const struct cl_option cl_options[] =
309 #endif
310 {
311 COMMAND_LINE_OPTIONS
312 };
313 #undef OPT
314 #undef COMMAND_LINE_OPTIONS
315
316 /* Holds switches parsed by c_common_decode_option (), but whose
317 handling is deffered to c_common_post_options (). */
318 static void defer_opt PARAMS ((enum opt_code, const char *));
319 static struct deferred_opt
320 {
321 enum opt_code code;
322 const char *arg;
323 } *deferred_opts;
324
325
326 #ifdef HOST_EBCDIC
327 static int opt_comp PARAMS ((const void *, const void *));
328
329 /* Run-time sorting of options array. */
330 static int
331 opt_comp (p1, p2)
332 const void *p1, *p2;
333 {
334 return strcmp (((struct cl_option *) p1)->opt_text,
335 ((struct cl_option *) p2)->opt_text);
336 }
337 #endif
338
339 /* Complain that switch OPT_INDEX expects an argument but none was
340 provided. */
341 static void
342 missing_arg (opt_index)
343 size_t opt_index;
344 {
345 const char *opt_text = cl_options[opt_index].opt_text;
346
347 switch (cl_options[opt_index].opt_code)
348 {
349 case OPT__output_pch:
350 case OPT_Wformat_eq:
351 case OPT_d:
352 case OPT_fabi_version:
353 case OPT_fbuiltin_:
354 case OPT_fdump:
355 case OPT_fname_mangling:
356 case OPT_ftabstop:
357 case OPT_ftemplate_depth:
358 default:
359 error ("missing argument to \"-%s\"", opt_text);
360 break;
361
362 case OPT_fconstant_string_class:
363 error ("no class name specified with \"-%s\"", opt_text);
364 break;
365
366 case OPT_MF:
367 case OPT_MD:
368 case OPT_MMD:
369 case OPT_o:
370 error ("missing filename after \"-%s\"", opt_text);
371 break;
372
373 case OPT_MQ:
374 case OPT_MT:
375 error ("missing target after \"-%s\"", opt_text);
376 break;
377 }
378 }
379
380 /* Perform a binary search to find which option the command-line INPUT
381 matches. Returns its index in the option array, and N_OPTS on
382 failure.
383
384 Complications arise since some options can be suffixed with an
385 argument, and multiple complete matches can occur, e.g. -pedantic
386 and -pedantic-errors. Also, some options are only accepted by some
387 languages. If a switch matches for a different language and
388 doesn't match any alternatives for the true front end, the index of
389 the matched switch is returned anyway. The caller should check for
390 this case. */
391 static size_t
392 find_opt (input, lang_flag)
393 const char *input;
394 int lang_flag;
395 {
396 size_t md, mn, mx;
397 size_t opt_len;
398 size_t result = N_OPTS;
399 int comp;
400
401 mn = 0;
402 mx = N_OPTS;
403
404 while (mx > mn)
405 {
406 md = (mn + mx) / 2;
407
408 opt_len = cl_options[md].opt_len;
409 comp = strncmp (input, cl_options[md].opt_text, opt_len);
410
411 if (comp < 0)
412 mx = md;
413 else if (comp > 0)
414 mn = md + 1;
415 else
416 {
417 /* The switch matches. It it an exact match? */
418 if (input[opt_len] == '\0')
419 return md;
420 else
421 {
422 mn = md + 1;
423
424 /* If the switch takes no arguments this is not a proper
425 match, so we continue the search (e.g. input="stdc++"
426 match was "stdc"). */
427 if (!(cl_options[md].flags & CL_JOINED))
428 continue;
429
430 /* Is this switch valid for this front end? */
431 if (!(cl_options[md].flags & lang_flag))
432 {
433 /* If subsequently we don't find a better match,
434 return this and let the caller report it as a bad
435 match. */
436 result = md;
437 continue;
438 }
439
440 /* Two scenarios remain: we have the switch's argument,
441 or we match a longer option. This can happen with
442 -iwithprefix and -withprefixbefore. The longest
443 possible option match succeeds.
444
445 Scan forwards, and return an exact match. Otherwise
446 return the longest valid option-accepting match (mx).
447 This loops at most twice with current options. */
448 mx = md;
449 for (md = md + 1; md < (size_t) N_OPTS; md++)
450 {
451 opt_len = cl_options[md].opt_len;
452 if (strncmp (input, cl_options[md].opt_text, opt_len))
453 break;
454 if (input[opt_len] == '\0')
455 return md;
456 if (cl_options[md].flags & lang_flag
457 && cl_options[md].flags & CL_JOINED)
458 mx = md;
459 }
460
461 return mx;
462 }
463 }
464 }
465
466 return result;
467 }
468
469 /* Defer option CODE with argument ARG. */
470 static void
471 defer_opt (code, arg)
472 enum opt_code code;
473 const char *arg;
474 {
475 /* FIXME: this should be in c_common_init_options, which should take
476 argc and argv. */
477 if (!deferred_opts)
478 {
479 extern int save_argc;
480 deferred_size = save_argc;
481 deferred_opts = (struct deferred_opt *)
482 xmalloc (deferred_size * sizeof (struct deferred_opt));
483 }
484
485 if (deferred_count == deferred_size)
486 abort ();
487
488 deferred_opts[deferred_count].code = code;
489 deferred_opts[deferred_count].arg = arg;
490 deferred_count++;
491 }
492
493 /* Common initialization before parsing options. */
494 void
495 c_common_init_options (lang)
496 enum c_language_kind lang;
497 {
498 #ifdef HOST_EBCDIC
499 /* For non-ASCII hosts, the cl_options array needs to be sorted at
500 runtime. */
501 qsort (cl_options, N_OPTS, sizeof (struct cl_option), opt_comp);
502 #endif
503 #if ENABLE_CHECKING
504 {
505 size_t i;
506
507 for (i = 1; i < N_OPTS; i++)
508 if (strcmp (cl_options[i - 1].opt_text, cl_options[i].opt_text) >= 0)
509 error ("options array incorrectly sorted: %s is before %s",
510 cl_options[i - 1].opt_text, cl_options[i].opt_text);
511 }
512 #endif
513
514 c_language = lang;
515 parse_in = cpp_create_reader (lang == clk_c ? CLK_GNUC89 : CLK_GNUCXX);
516 cpp_opts = cpp_get_options (parse_in);
517 if (flag_objc)
518 cpp_opts->objc = 1;
519
520 flag_const_strings = (lang == clk_cplusplus);
521 warn_pointer_arith = (lang == clk_cplusplus);
522 if (lang == clk_c)
523 warn_sign_compare = -1;
524 }
525
526 /* Handle one command-line option in (argc, argv).
527 Can be called multiple times, to handle multiple sets of options.
528 Returns number of strings consumed. */
529 int
530 c_common_decode_option (argc, argv)
531 int argc;
532 char **argv;
533 {
534 static const int lang_flags[] = {CL_C_ONLY, CL_C, CL_CXX_ONLY, CL_CXX};
535 size_t opt_index;
536 const char *opt, *arg = 0;
537 char *dup = 0;
538 bool on = true;
539 int result, lang_flag;
540 const struct cl_option *option;
541 enum opt_code code;
542
543 opt = argv[0];
544
545 /* Interpret "-" or a non-switch as a file name. */
546 if (opt[0] != '-' || opt[1] == '\0')
547 {
548 if (!in_fname)
549 in_fname = opt;
550 else if (!out_fname)
551 out_fname = opt;
552 else
553 {
554 error ("too many filenames given. Type %s --help for usage",
555 progname);
556 return argc;
557 }
558
559 return 1;
560 }
561
562 /* Drop the "no-" from negative switches. */
563 if ((opt[1] == 'W' || opt[1] == 'f')
564 && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
565 {
566 size_t len = strlen (opt) - 3;
567
568 dup = xmalloc (len + 1);
569 dup[0] = '-';
570 dup[1] = opt[1];
571 memcpy (dup + 2, opt + 5, len - 2 + 1);
572 opt = dup;
573 on = false;
574 }
575
576 result = cpp_handle_option (parse_in, argc, argv);
577
578 /* Skip over '-'. */
579 lang_flag = lang_flags[(c_language << 1) + flag_objc];
580 opt_index = find_opt (opt + 1, lang_flag);
581 if (opt_index == N_OPTS)
582 goto done;
583
584 result = 1;
585 option = &cl_options[opt_index];
586
587 /* Sort out any argument the switch takes. */
588 if (option->flags & CL_ARG)
589 {
590 if (option->flags & CL_JOINED)
591 {
592 /* Have arg point to the original switch. This is because
593 some code, such as disable_builtin_function, expects its
594 argument to be persistent until the program exits. */
595 arg = argv[0] + cl_options[opt_index].opt_len + 1;
596 if (!on)
597 arg += strlen ("no-");
598 }
599
600 /* If we don't have an argument, and CL_SEPARATE, try the next
601 argument in the vector. */
602 if (!arg || (*arg == '\0' && option->flags & CL_SEPARATE))
603 {
604 arg = argv[1];
605 result = 2;
606 }
607
608 if (!arg || *arg == '\0')
609 {
610 missing_arg (opt_index);
611 result = argc;
612 goto done;
613 }
614 }
615
616 /* Complain about the wrong language after we've swallowed any
617 necessary extra argument. Eventually make this a hard error
618 after the call to find_opt, and return argc. */
619 if (!(cl_options[opt_index].flags & lang_flag))
620 {
621 complain_wrong_lang (opt_index);
622 goto done;
623 }
624
625 switch (code = option->opt_code)
626 {
627 case N_OPTS: /* Shut GCC up. */
628 break;
629
630 case OPT__help:
631 print_help ();
632 break;
633
634 case OPT__output_pch:
635 pch_file = arg;
636 break;
637
638 case OPT_C:
639 cpp_opts->discard_comments = 0;
640 break;
641
642 case OPT_CC:
643 cpp_opts->discard_comments = 0;
644 cpp_opts->discard_comments_in_macro_exp = 0;
645 break;
646
647 case OPT_E:
648 flag_preprocess_only = 1;
649 break;
650
651 case OPT_H:
652 cpp_opts->print_include_names = 1;
653 break;
654
655 case OPT_M:
656 case OPT_MM:
657 /* When doing dependencies with -M or -MM, suppress normal
658 preprocessed output, but still do -dM etc. as software
659 depends on this. Preprocessed output does occur if -MD, -MMD
660 or environment var dependency generation is used. */
661 cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER);
662 cpp_opts->no_output = 1;
663 cpp_opts->inhibit_warnings = 1;
664 break;
665
666 case OPT_MD:
667 case OPT_MMD:
668 cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER);
669 deps_file = arg;
670 break;
671
672 case OPT_MF:
673 deps_seen = true;
674 deps_file = arg;
675 break;
676
677 case OPT_MG:
678 deps_seen = true;
679 cpp_opts->deps.missing_files = true;
680 break;
681
682 case OPT_MP:
683 deps_seen = true;
684 cpp_opts->deps.phony_targets = true;
685 break;
686
687 case OPT_MQ:
688 case OPT_MT:
689 deps_seen = true;
690 defer_opt (code, arg);
691 break;
692
693 case OPT_P:
694 cpp_opts->no_line_commands = 1;
695 break;
696
697 case OPT_Wabi:
698 warn_abi = on;
699 break;
700
701 case OPT_Wall:
702 set_Wunused (on);
703 set_Wformat (on);
704 set_Wimplicit (on);
705 warn_char_subscripts = on;
706 warn_missing_braces = on;
707 warn_parentheses = on;
708 warn_return_type = on;
709 warn_sequence_point = on; /* Was C only. */
710 warn_sign_compare = on; /* Was C++ only. */
711 warn_switch = on;
712 warn_strict_aliasing = on;
713
714 /* Only warn about unknown pragmas that are not in system
715 headers. */
716 warn_unknown_pragmas = on;
717
718 /* We save the value of warn_uninitialized, since if they put
719 -Wuninitialized on the command line, we need to generate a
720 warning about not using it without also specifying -O. */
721 if (warn_uninitialized != 1)
722 warn_uninitialized = (on ? 2 : 0);
723
724 if (c_language == clk_c)
725 /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding
726 can turn it off only if it's not explicit. */
727 warn_main = on * 2;
728 else
729 {
730 /* C++-specific warnings. */
731 warn_ctor_dtor_privacy = on;
732 warn_nonvdtor = on;
733 warn_reorder = on;
734 warn_nontemplate_friend = on;
735 }
736
737 cpp_opts->warn_trigraphs = on;
738 cpp_opts->warn_comments = on;
739 cpp_opts->warn_num_sign_change = on;
740 cpp_opts->warn_multichar = on; /* Was C++ only. */
741 break;
742
743 case OPT_Wbad_function_cast:
744 warn_bad_function_cast = on;
745 break;
746
747 case OPT_Wcast_qual:
748 warn_cast_qual = on;
749 break;
750
751 case OPT_Wchar_subscripts:
752 warn_char_subscripts = on;
753 break;
754
755 case OPT_Wcomment:
756 case OPT_Wcomments:
757 cpp_opts->warn_comments = on;
758 break;
759
760 case OPT_Wconversion:
761 warn_conversion = on;
762 break;
763
764 case OPT_Wctor_dtor_privacy:
765 warn_ctor_dtor_privacy = on;
766 break;
767
768 case OPT_Wdeprecated:
769 warn_deprecated = on;
770 break;
771
772 case OPT_Wdiv_by_zero:
773 warn_div_by_zero = on;
774 break;
775
776 case OPT_Weffcxx:
777 warn_ecpp = on;
778 break;
779
780 case OPT_Wendif_labels:
781 cpp_opts->warn_endif_labels = on;
782 break;
783
784 case OPT_Werror:
785 cpp_opts->warnings_are_errors = on;
786 break;
787
788 case OPT_Werror_implicit_function_decl:
789 if (!on)
790 result = 0;
791 else
792 mesg_implicit_function_declaration = 2;
793 break;
794
795 case OPT_Wfloat_equal:
796 warn_float_equal = on;
797 break;
798
799 case OPT_Wformat:
800 set_Wformat (on);
801 break;
802
803 case OPT_Wformat_eq:
804 set_Wformat (atoi (arg));
805 break;
806
807 case OPT_Wformat_extra_args:
808 warn_format_extra_args = on;
809 break;
810
811 case OPT_Wformat_nonliteral:
812 warn_format_nonliteral = on;
813 break;
814
815 case OPT_Wformat_security:
816 warn_format_security = on;
817 break;
818
819 case OPT_Wformat_y2k:
820 warn_format_y2k = on;
821 break;
822
823 case OPT_Wformat_zero_length:
824 warn_format_zero_length = on;
825 break;
826
827 case OPT_Wimplicit:
828 set_Wimplicit (on);
829 break;
830
831 case OPT_Wimplicit_function_decl:
832 mesg_implicit_function_declaration = on;
833 break;
834
835 case OPT_Wimplicit_int:
836 warn_implicit_int = on;
837 break;
838
839 case OPT_Wimport:
840 cpp_opts->warn_import = on;
841 break;
842
843 case OPT_Winvalid_pch:
844 cpp_opts->warn_invalid_pch = on;
845 break;
846
847 case OPT_Wlong_long:
848 warn_long_long = on;
849 break;
850
851 case OPT_Wmain:
852 if (on)
853 warn_main = 1;
854 else
855 warn_main = -1;
856 break;
857
858 case OPT_Wmissing_braces:
859 warn_missing_braces = on;
860 break;
861
862 case OPT_Wmissing_declarations:
863 warn_missing_declarations = on;
864 break;
865
866 case OPT_Wmissing_format_attribute:
867 warn_missing_format_attribute = on;
868 break;
869
870 case OPT_Wmissing_prototypes:
871 warn_missing_prototypes = on;
872 break;
873
874 case OPT_Wmultichar:
875 cpp_opts->warn_multichar = on;
876 break;
877
878 case OPT_Wnested_externs:
879 warn_nested_externs = on;
880 break;
881
882 case OPT_Wnon_template_friend:
883 warn_nontemplate_friend = on;
884 break;
885
886 case OPT_Wnon_virtual_dtor:
887 warn_nonvdtor = on;
888 break;
889
890 case OPT_Wnonnull:
891 warn_nonnull = on;
892 break;
893
894 case OPT_Wold_style_cast:
895 warn_old_style_cast = on;
896 break;
897
898 case OPT_Woverloaded_virtual:
899 warn_overloaded_virtual = on;
900 break;
901
902 case OPT_Wparentheses:
903 warn_parentheses = on;
904 break;
905
906 case OPT_Wpmf_conversions:
907 warn_pmf2ptr = on;
908 break;
909
910 case OPT_Wpointer_arith:
911 warn_pointer_arith = on;
912 break;
913
914 case OPT_Wprotocol:
915 warn_protocol = on;
916 break;
917
918 case OPT_Wselector:
919 warn_selector = on;
920 break;
921
922 case OPT_Wredundant_decls:
923 warn_redundant_decls = on;
924 break;
925
926 case OPT_Wreorder:
927 warn_reorder = on;
928 break;
929
930 case OPT_Wreturn_type:
931 warn_return_type = on;
932 break;
933
934 case OPT_Wsequence_point:
935 warn_sequence_point = on;
936 break;
937
938 case OPT_Wsign_compare:
939 warn_sign_compare = on;
940 break;
941
942 case OPT_Wsign_promo:
943 warn_sign_promo = on;
944 break;
945
946 case OPT_Wstrict_prototypes:
947 if (!on && c_language == clk_cplusplus)
948 warning ("-Wno-strict-prototypes is not supported in C++");
949 else
950 warn_strict_prototypes = on;
951 break;
952
953 case OPT_Wsynth:
954 warn_synth = on;
955 break;
956
957 case OPT_Wsystem_headers:
958 cpp_opts->warn_system_headers = on;
959 break;
960
961 case OPT_Wtraditional:
962 warn_traditional = on;
963 cpp_opts->warn_traditional = on;
964 break;
965
966 case OPT_Wtrigraphs:
967 cpp_opts->warn_trigraphs = on;
968 break;
969
970 case OPT_Wundeclared_selector:
971 warn_undeclared_selector = on;
972 break;
973
974 case OPT_Wundef:
975 cpp_opts->warn_undef = on;
976 break;
977
978 case OPT_Wunknown_pragmas:
979 /* Set to greater than 1, so that even unknown pragmas in
980 system headers will be warned about. */
981 warn_unknown_pragmas = on * 2;
982 break;
983
984 case OPT_Wunused_macros:
985 cpp_opts->warn_unused_macros = on;
986 break;
987
988 case OPT_Wwrite_strings:
989 if (c_language == clk_c)
990 flag_const_strings = on;
991 else
992 warn_write_strings = on;
993 break;
994
995 case OPT_ansi:
996 if (c_language == clk_c)
997 set_std_c89 (false, true);
998 else
999 set_std_cxx98 (true);
1000 break;
1001
1002 case OPT_d:
1003 handle_OPT_d (arg);
1004 break;
1005
1006 case OPT_fcond_mismatch:
1007 if (c_language == clk_c)
1008 {
1009 flag_cond_mismatch = on;
1010 break;
1011 }
1012 /* Fall through. */
1013
1014 case OPT_fall_virtual:
1015 case OPT_fenum_int_equiv:
1016 case OPT_fguiding_decls:
1017 case OPT_fhonor_std:
1018 case OPT_fhuge_objects:
1019 case OPT_flabels_ok:
1020 case OPT_fname_mangling:
1021 case OPT_fnew_abi:
1022 case OPT_fnonnull_objects:
1023 case OPT_fsquangle:
1024 case OPT_fstrict_prototype:
1025 case OPT_fthis_is_variable:
1026 case OPT_fvtable_thunks:
1027 case OPT_fxref:
1028 warning ("switch \"%s\" is no longer supported", argv[0]);
1029 break;
1030
1031 case OPT_fabi_version:
1032 flag_abi_version = read_integral_parameter (arg, argv[0], 1);
1033 break;
1034
1035 case OPT_faccess_control:
1036 flag_access_control = on;
1037 break;
1038
1039 case OPT_falt_external_templates:
1040 flag_alt_external_templates = on;
1041 if (on)
1042 flag_external_templates = true;
1043 cp_deprecated:
1044 warning ("switch \"%s\" is deprecated, please see documentation for details", argv[0]);
1045 break;
1046
1047 case OPT_fasm:
1048 flag_no_asm = !on;
1049 break;
1050
1051 case OPT_fbuiltin:
1052 flag_no_builtin = !on;
1053 break;
1054
1055 case OPT_fbuiltin_:
1056 if (on)
1057 result = 0;
1058 else
1059 disable_builtin_function (arg);
1060 break;
1061
1062 case OPT_fdollars_in_identifiers:
1063 dollars_in_ident = on;
1064 break;
1065
1066 case OPT_fdump:
1067 if (!on || !dump_switch_p (argv[0] + strlen ("-f")))
1068 result = 0;
1069 break;
1070
1071 case OPT_ffreestanding:
1072 on = !on;
1073 /* Fall through... */
1074 case OPT_fhosted:
1075 flag_hosted = on;
1076 flag_no_builtin = !on;
1077 /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
1078 if (!on && warn_main == 2)
1079 warn_main = 0;
1080 break;
1081
1082 case OPT_fshort_double:
1083 flag_short_double = on;
1084 break;
1085
1086 case OPT_fshort_enums:
1087 flag_short_enums = on;
1088 break;
1089
1090 case OPT_fshort_wchar:
1091 flag_short_wchar = on;
1092 break;
1093
1094 case OPT_fsigned_bitfields:
1095 flag_signed_bitfields = on;
1096 explicit_flag_signed_bitfields = 1;
1097 break;
1098
1099 case OPT_fsigned_char:
1100 flag_signed_char = on;
1101 break;
1102
1103 case OPT_funsigned_bitfields:
1104 flag_signed_bitfields = !on;
1105 explicit_flag_signed_bitfields = 1;
1106 break;
1107
1108 case OPT_funsigned_char:
1109 flag_signed_char = !on;
1110 break;
1111
1112 case OPT_fcheck_new:
1113 flag_check_new = on;
1114 break;
1115
1116 case OPT_fconserve_space:
1117 flag_conserve_space = on;
1118 break;
1119
1120 case OPT_fconst_strings:
1121 flag_const_strings = on;
1122 break;
1123
1124 case OPT_fconstant_string_class:
1125 constant_string_class_name = arg;
1126 break;
1127
1128 case OPT_fdefault_inline:
1129 flag_default_inline = on;
1130 break;
1131
1132 case OPT_felide_constructors:
1133 flag_elide_constructors = on;
1134 break;
1135
1136 case OPT_fenforce_eh_specs:
1137 flag_enforce_eh_specs = on;
1138 break;
1139
1140 case OPT_fexternal_templates:
1141 flag_external_templates = on;
1142 goto cp_deprecated;
1143
1144 case OPT_ffor_scope:
1145 flag_new_for_scope = on;
1146 break;
1147
1148 case OPT_fgnu_keywords:
1149 flag_no_gnu_keywords = !on;
1150 break;
1151
1152 case OPT_fgnu_runtime:
1153 flag_next_runtime = !on;
1154 break;
1155
1156 case OPT_fhandle_exceptions:
1157 warning ("-fhandle-exceptions has been renamed to -fexceptions (and is now on by default)");
1158 flag_exceptions = on;
1159 break;
1160
1161 case OPT_fimplement_inlines:
1162 flag_implement_inlines = on;
1163 break;
1164
1165 case OPT_fimplicit_inline_templates:
1166 flag_implicit_inline_templates = on;
1167 break;
1168
1169 case OPT_fimplicit_templates:
1170 flag_implicit_templates = on;
1171 break;
1172
1173 case OPT_fms_extensions:
1174 flag_ms_extensions = on;
1175 break;
1176
1177 case OPT_fnext_runtime:
1178 flag_next_runtime = on;
1179 break;
1180
1181 case OPT_fnonansi_builtins:
1182 flag_no_nonansi_builtin = !on;
1183 break;
1184
1185 case OPT_foperator_names:
1186 cpp_opts->operator_names = on;
1187 break;
1188
1189 case OPT_foptional_diags:
1190 flag_optional_diags = on;
1191 break;
1192
1193 case OPT_fpch_deps:
1194 cpp_opts->restore_pch_deps = on;
1195 break;
1196
1197 case OPT_fpermissive:
1198 flag_permissive = on;
1199 break;
1200
1201 case OPT_fpreprocessed:
1202 cpp_opts->preprocessed = on;
1203 break;
1204
1205 case OPT_frepo:
1206 flag_use_repository = on;
1207 if (on)
1208 flag_implicit_templates = 0;
1209 break;
1210
1211 case OPT_frtti:
1212 flag_rtti = on;
1213 break;
1214
1215 case OPT_fshow_column:
1216 cpp_opts->show_column = on;
1217 break;
1218
1219 case OPT_fstats:
1220 flag_detailed_statistics = on;
1221 break;
1222
1223 case OPT_ftabstop:
1224 /* Don't recognize -fno-tabstop=. */
1225 if (!on)
1226 return 0;
1227
1228 /* It is documented that we silently ignore silly values. */
1229 {
1230 char *endptr;
1231 long tabstop = strtol (arg, &endptr, 10);
1232 if (*endptr == '\0' && tabstop >= 1 && tabstop <= 100)
1233 cpp_opts->tabstop = tabstop;
1234 }
1235 break;
1236
1237 case OPT_ftemplate_depth:
1238 max_tinst_depth = read_integral_parameter (arg, argv[0], 0);
1239 break;
1240
1241 case OPT_fvtable_gc:
1242 flag_vtable_gc = on;
1243 break;
1244
1245 case OPT_fuse_cxa_atexit:
1246 flag_use_cxa_atexit = on;
1247 break;
1248
1249 case OPT_fweak:
1250 flag_weak = on;
1251 break;
1252
1253 case OPT_gen_decls:
1254 flag_gen_declaration = 1;
1255 break;
1256
1257 case OPT_lang_asm:
1258 cpp_set_lang (parse_in, CLK_ASM);
1259 break;
1260
1261 case OPT_lang_objc:
1262 cpp_opts->objc = 1;
1263 break;
1264
1265 case OPT_nostdinc:
1266 /* No default include directories. You must specify all
1267 include-file directories with -I. */
1268 cpp_opts->no_standard_includes = 1;
1269 break;
1270
1271 case OPT_nostdincplusplus:
1272 /* No default C++-specific include directories. */
1273 cpp_opts->no_standard_cplusplus_includes = 1;
1274 break;
1275
1276 case OPT_o:
1277 if (!out_fname)
1278 out_fname = arg;
1279 else
1280 {
1281 error ("output filename specified twice");
1282 result = argc;
1283 }
1284 break;
1285
1286 /* We need to handle the -pedantic switches here, rather than in
1287 c_common_post_options, so that a subsequent -Wno-endif-labels
1288 is not overridden. */
1289 case OPT_pedantic_errors:
1290 cpp_opts->pedantic_errors = 1;
1291 /* fall through */
1292 case OPT_pedantic:
1293 cpp_opts->pedantic = 1;
1294 cpp_opts->warn_endif_labels = 1;
1295 break;
1296
1297 case OPT_print_objc_runtime_info:
1298 print_struct_values = 1;
1299 break;
1300
1301 case OPT_remap:
1302 cpp_opts->remap = 1;
1303 break;
1304
1305 case OPT_std_cplusplus98:
1306 case OPT_std_gnuplusplus98:
1307 set_std_cxx98 (code == OPT_std_cplusplus98 /* ISO */);
1308 break;
1309
1310 case OPT_std_c89:
1311 case OPT_std_iso9899_1990:
1312 case OPT_std_iso9899_199409:
1313 set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
1314 break;
1315
1316 case OPT_std_gnu89:
1317 set_std_c89 (false /* c94 */, false /* ISO */);
1318 break;
1319
1320 case OPT_std_c99:
1321 case OPT_std_c9x:
1322 case OPT_std_iso9899_1999:
1323 case OPT_std_iso9899_199x:
1324 set_std_c99 (true /* ISO */);
1325 break;
1326
1327 case OPT_std_gnu99:
1328 case OPT_std_gnu9x:
1329 set_std_c99 (false /* ISO */);
1330 break;
1331
1332 case OPT_trigraphs:
1333 cpp_opts->trigraphs = 1;
1334 break;
1335
1336 case OPT_traditional_cpp:
1337 cpp_opts->traditional = 1;
1338 break;
1339
1340 case OPT_undef:
1341 flag_undef = 1;
1342 break;
1343
1344 case OPT_w:
1345 cpp_opts->inhibit_warnings = 1;
1346 break;
1347
1348 case OPT_v:
1349 cpp_opts->verbose = 1;
1350 break;
1351 }
1352
1353 done:
1354 if (dup)
1355 free (dup);
1356 return result;
1357 }
1358
1359 /* Post-switch processing. */
1360 bool
1361 c_common_post_options ()
1362 {
1363 /* Canonicalize the input and output filenames. */
1364 if (in_fname == NULL || !strcmp (in_fname, "-"))
1365 in_fname = "";
1366
1367 if (out_fname == NULL || !strcmp (out_fname, "-"))
1368 out_fname = "";
1369
1370 if (cpp_opts->deps.style == DEPS_NONE)
1371 check_deps_environment_vars ();
1372
1373 handle_deferred_opts ();
1374
1375 sanitize_cpp_opts ();
1376
1377 flag_inline_trees = 1;
1378
1379 /* Use tree inlining if possible. Function instrumentation is only
1380 done in the RTL level, so we disable tree inlining. */
1381 if (! flag_instrument_function_entry_exit)
1382 {
1383 if (!flag_no_inline)
1384 flag_no_inline = 1;
1385 if (flag_inline_functions)
1386 {
1387 flag_inline_trees = 2;
1388 flag_inline_functions = 0;
1389 }
1390 }
1391
1392 /* Special format checking options don't work without -Wformat; warn if
1393 they are used. */
1394 if (warn_format_y2k && !warn_format)
1395 warning ("-Wformat-y2k ignored without -Wformat");
1396 if (warn_format_extra_args && !warn_format)
1397 warning ("-Wformat-extra-args ignored without -Wformat");
1398 if (warn_format_zero_length && !warn_format)
1399 warning ("-Wformat-zero-length ignored without -Wformat");
1400 if (warn_format_nonliteral && !warn_format)
1401 warning ("-Wformat-nonliteral ignored without -Wformat");
1402 if (warn_format_security && !warn_format)
1403 warning ("-Wformat-security ignored without -Wformat");
1404 if (warn_missing_format_attribute && !warn_format)
1405 warning ("-Wmissing-format-attribute ignored without -Wformat");
1406
1407 /* If an error has occurred in cpplib, note it so we fail
1408 immediately. */
1409 errorcount += cpp_errors (parse_in);
1410
1411 return flag_preprocess_only;
1412 }
1413
1414 /* Preprocess the input file to out_stream. */
1415 static void
1416 preprocess_file ()
1417 {
1418 /* Open the output now. We must do so even if no_output is on,
1419 because there may be other output than from the actual
1420 preprocessing (e.g. from -dM). */
1421 if (out_fname[0] == '\0')
1422 out_stream = stdout;
1423 else
1424 out_stream = fopen (out_fname, "w");
1425
1426 if (out_stream == NULL)
1427 fatal_io_error ("opening output file %s", out_fname);
1428 else
1429 cpp_preprocess_file (parse_in, in_fname, out_stream);
1430 }
1431
1432 /* Front end initialization common to C, ObjC and C++. */
1433 const char *
1434 c_common_init (filename)
1435 const char *filename;
1436 {
1437 /* Set up preprocessor arithmetic. Must be done after call to
1438 c_common_nodes_and_builtins for type nodes to be good. */
1439 cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1440 cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1441 cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1442 cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1443 cpp_opts->unsigned_wchar = TREE_UNSIGNED (wchar_type_node);
1444
1445 /* Register preprocessor built-ins before calls to
1446 cpp_main_file. */
1447 cpp_get_callbacks (parse_in)->register_builtins = cb_register_builtins;
1448
1449 /* NULL is passed up to toplev.c and we exit quickly. */
1450 if (flag_preprocess_only)
1451 {
1452 preprocess_file ();
1453 return NULL;
1454 }
1455
1456 /* Do this before initializing pragmas, as then cpplib's hash table
1457 has been set up. NOTE: we are using our own file name here, not
1458 the one supplied. */
1459 filename = init_c_lex (in_fname);
1460
1461 init_pragma ();
1462
1463 return filename;
1464 }
1465
1466 /* Common finish hook for the C, ObjC and C++ front ends. */
1467 void
1468 c_common_finish ()
1469 {
1470 FILE *deps_stream = NULL;
1471
1472 if (cpp_opts->deps.style != DEPS_NONE)
1473 {
1474 /* If -M or -MM was seen without -MF, default output to the
1475 output stream. */
1476 if (!deps_file)
1477 deps_stream = out_stream;
1478 else
1479 {
1480 deps_stream = fopen (deps_file, deps_append ? "a": "w");
1481 if (!deps_stream)
1482 fatal_io_error ("opening dependency file %s", deps_file);
1483 }
1484 }
1485
1486 /* For performance, avoid tearing down cpplib's internal structures
1487 with cpp_destroy (). */
1488 errorcount += cpp_finish (parse_in, deps_stream);
1489
1490 if (deps_stream && deps_stream != out_stream
1491 && (ferror (deps_stream) || fclose (deps_stream)))
1492 fatal_io_error ("closing dependency file %s", deps_file);
1493
1494 if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1495 fatal_io_error ("when writing output to %s", out_fname);
1496 }
1497
1498 /* Either of two environment variables can specify output of
1499 dependencies. Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1500 DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1501 and DEPS_TARGET is the target to mention in the deps. They also
1502 result in dependency information being appended to the output file
1503 rather than overwriting it, and like Sun's compiler
1504 SUNPRO_DEPENDENCIES suppresses the dependency on the main file. */
1505 static void
1506 check_deps_environment_vars ()
1507 {
1508 char *spec;
1509
1510 GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1511 if (spec)
1512 cpp_opts->deps.style = DEPS_USER;
1513 else
1514 {
1515 GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1516 if (spec)
1517 {
1518 cpp_opts->deps.style = DEPS_SYSTEM;
1519 cpp_opts->deps.ignore_main_file = true;
1520 }
1521 }
1522
1523 if (spec)
1524 {
1525 /* Find the space before the DEPS_TARGET, if there is one. */
1526 char *s = strchr (spec, ' ');
1527 if (s)
1528 {
1529 /* Let the caller perform MAKE quoting. */
1530 defer_opt (OPT_MT, s + 1);
1531 *s = '\0';
1532 }
1533
1534 /* Command line -MF overrides environment variables and default. */
1535 if (!deps_file)
1536 deps_file = spec;
1537
1538 deps_append = 1;
1539 }
1540 }
1541
1542 /* Handle deferred command line switches. */
1543 static void
1544 handle_deferred_opts ()
1545 {
1546 size_t i;
1547
1548 for (i = 0; i < deferred_count; i++)
1549 {
1550 struct deferred_opt *opt = &deferred_opts[i];
1551
1552 switch (opt->code)
1553 {
1554 case OPT_MT:
1555 case OPT_MQ:
1556 cpp_add_dependency_target (parse_in, opt->arg, opt->code == OPT_MQ);
1557 break;
1558
1559 default:
1560 abort ();
1561 }
1562 }
1563
1564 free (deferred_opts);
1565 }
1566
1567 /* These settings are appropriate for GCC, but not necessarily so for
1568 cpplib as a library. */
1569 static void
1570 sanitize_cpp_opts ()
1571 {
1572 /* If we don't know what style of dependencies to output, complain
1573 if any other dependency switches have been given. */
1574 if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1575 error ("to generate dependencies you must specify either -M or -MM");
1576
1577 /* -dM and dependencies suppress normal output; do it here so that
1578 the last -d[MDN] switch overrides earlier ones. */
1579 if (cpp_opts->dump_macros == dump_only)
1580 cpp_opts->no_output = 1;
1581
1582 /* Disable -dD, -dN and -dI if normal output is suppressed. Allow
1583 -dM since at least glibc relies on -M -dM to work. */
1584 if (cpp_opts->no_output)
1585 {
1586 if (cpp_opts->dump_macros != dump_only)
1587 cpp_opts->dump_macros = dump_none;
1588 cpp_opts->dump_includes = 0;
1589 }
1590
1591 cpp_opts->unsigned_char = !flag_signed_char;
1592 cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1593
1594 /* We want -Wno-long-long to override -pedantic -std=non-c99
1595 and/or -Wtraditional, whatever the ordering. */
1596 cpp_opts->warn_long_long
1597 = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
1598 }
1599
1600 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1601 extensions if ISO). There is no concept of gnu94. */
1602 static void
1603 set_std_c89 (c94, iso)
1604 int c94, iso;
1605 {
1606 cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1607 flag_iso = iso;
1608 flag_no_asm = iso;
1609 flag_no_gnu_keywords = iso;
1610 flag_no_nonansi_builtin = iso;
1611 flag_noniso_default_format_attributes = !iso;
1612 flag_isoc94 = c94;
1613 flag_isoc99 = 0;
1614 flag_writable_strings = 0;
1615 }
1616
1617 /* Set the C 99 standard (without GNU extensions if ISO). */
1618 static void
1619 set_std_c99 (iso)
1620 int iso;
1621 {
1622 cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1623 flag_no_asm = iso;
1624 flag_no_nonansi_builtin = iso;
1625 flag_noniso_default_format_attributes = !iso;
1626 flag_iso = iso;
1627 flag_isoc99 = 1;
1628 flag_isoc94 = 1;
1629 flag_writable_strings = 0;
1630 }
1631
1632 /* Set the C++ 98 standard (without GNU extensions if ISO). */
1633 static void
1634 set_std_cxx98 (iso)
1635 int iso;
1636 {
1637 cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1638 flag_no_gnu_keywords = iso;
1639 flag_no_nonansi_builtin = iso;
1640 flag_noniso_default_format_attributes = !iso;
1641 flag_iso = iso;
1642 }
1643
1644 /* Handle setting implicit to ON. */
1645 static void
1646 set_Wimplicit (on)
1647 int on;
1648 {
1649 warn_implicit = on;
1650 warn_implicit_int = on;
1651 if (on)
1652 {
1653 if (mesg_implicit_function_declaration != 2)
1654 mesg_implicit_function_declaration = 1;
1655 }
1656 else
1657 mesg_implicit_function_declaration = 0;
1658 }
1659
1660 /* Args to -d specify what to dump. Silently ignore
1661 unrecognized options; they may be aimed at toplev.c. */
1662 static void
1663 handle_OPT_d (arg)
1664 const char *arg;
1665 {
1666 char c;
1667
1668 while ((c = *arg++) != '\0')
1669 switch (c)
1670 {
1671 case 'M':
1672 cpp_opts->dump_macros = dump_only;
1673 break;
1674
1675 case 'N':
1676 cpp_opts->dump_macros = dump_names;
1677 break;
1678
1679 case 'D':
1680 cpp_opts->dump_macros = dump_definitions;
1681 break;
1682
1683 case 'I':
1684 cpp_opts->dump_includes = 1;
1685 break;
1686 }
1687 }
1688
1689 /* Write a slash-separated list of languages in FLAGS to BUF. */
1690 static void
1691 write_langs (buf, flags)
1692 char *buf;
1693 int flags;
1694 {
1695 *buf = '\0';
1696 if (flags & CL_C_ONLY)
1697 strcat (buf, "C");
1698 if (flags & CL_OBJC_ONLY)
1699 {
1700 if (*buf)
1701 strcat (buf, "/");
1702 strcat (buf, "ObjC");
1703 }
1704 if (flags & CL_CXX_ONLY)
1705 {
1706 if (*buf)
1707 strcat (buf, "/");
1708 strcat (buf, "C++");
1709 }
1710 }
1711
1712 /* Complain that switch OPT_INDEX does not apply to this front end. */
1713 static void
1714 complain_wrong_lang (opt_index)
1715 size_t opt_index;
1716 {
1717 char ok_langs[60], bad_langs[60];
1718 int ok_flags = cl_options[opt_index].flags;
1719
1720 write_langs (ok_langs, ok_flags);
1721 write_langs (bad_langs, ~ok_flags);
1722 warning ("\"-%s\" is valid for %s but not for %s",
1723 cl_options[opt_index].opt_text, ok_langs, bad_langs);
1724 }
1725
1726 /* Handle --help output. */
1727 static void
1728 print_help ()
1729 {
1730 /* To keep the lines from getting too long for some compilers, limit
1731 to about 500 characters (6 lines) per chunk. */
1732 fputs (_("\
1733 Switches:\n\
1734 -include <file> Include the contents of <file> before other files\n\
1735 -imacros <file> Accept definition of macros in <file>\n\
1736 -iprefix <path> Specify <path> as a prefix for next two options\n\
1737 -iwithprefix <dir> Add <dir> to the end of the system include path\n\
1738 -iwithprefixbefore <dir> Add <dir> to the end of the main include path\n\
1739 -isystem <dir> Add <dir> to the start of the system include path\n\
1740 "), stdout);
1741 fputs (_("\
1742 -idirafter <dir> Add <dir> to the end of the system include path\n\
1743 -I <dir> Add <dir> to the end of the main include path\n\
1744 -I- Fine-grained include path control; see info docs\n\
1745 -nostdinc Do not search system include directories\n\
1746 (dirs specified with -isystem will still be used)\n\
1747 -nostdinc++ Do not search system include directories for C++\n\
1748 -o <file> Put output into <file>\n\
1749 "), stdout);
1750 fputs (_("\
1751 -trigraphs Support ISO C trigraphs\n\
1752 -std=<std name> Specify the conformance standard; one of:\n\
1753 gnu89, gnu99, c89, c99, iso9899:1990,\n\
1754 iso9899:199409, iso9899:1999, c++98\n\
1755 -w Inhibit warning messages\n\
1756 -W[no-]trigraphs Warn if trigraphs are encountered\n\
1757 -W[no-]comment{s} Warn if one comment starts inside another\n\
1758 "), stdout);
1759 fputs (_("\
1760 -W[no-]traditional Warn about features not present in traditional C\n\
1761 -W[no-]undef Warn if an undefined macro is used by #if\n\
1762 -W[no-]import Warn about the use of the #import directive\n\
1763 "), stdout);
1764 fputs (_("\
1765 -W[no-]error Treat all warnings as errors\n\
1766 -W[no-]system-headers Do not suppress warnings from system headers\n\
1767 -W[no-]all Enable most preprocessor warnings\n\
1768 "), stdout);
1769 fputs (_("\
1770 -M Generate make dependencies\n\
1771 -MM As -M, but ignore system header files\n\
1772 -MD Generate make dependencies and compile\n\
1773 -MMD As -MD, but ignore system header files\n\
1774 -MF <file> Write dependency output to the given file\n\
1775 -MG Treat missing header file as generated files\n\
1776 "), stdout);
1777 fputs (_("\
1778 -MP Generate phony targets for all headers\n\
1779 -MQ <target> Add a MAKE-quoted target\n\
1780 -MT <target> Add an unquoted target\n\
1781 "), stdout);
1782 fputs (_("\
1783 -D<macro> Define a <macro> with string '1' as its value\n\
1784 -D<macro>=<val> Define a <macro> with <val> as its value\n\
1785 -A<question>=<answer> Assert the <answer> to <question>\n\
1786 -A-<question>=<answer> Disable the <answer> to <question>\n\
1787 -U<macro> Undefine <macro> \n\
1788 -v Display the version number\n\
1789 "), stdout);
1790 fputs (_("\
1791 -H Print the name of header files as they are used\n\
1792 -C Do not discard comments\n\
1793 -dM Display a list of macro definitions active at end\n\
1794 -dD Preserve macro definitions in output\n\
1795 -dN As -dD except that only the names are preserved\n\
1796 -dI Include #include directives in the output\n\
1797 "), stdout);
1798 fputs (_("\
1799 -f[no-]preprocessed Treat the input file as already preprocessed\n\
1800 -ftabstop=<number> Distance between tab stops for column reporting\n\
1801 -P Do not generate #line directives\n\
1802 -remap Remap file names when including files\n\
1803 --help Display this information\n\
1804 "), stdout);
1805 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org