?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
i386-protos.h (x86_emit_floatuns): Declare.
[official-gcc.git] / gcc / c-opts.c
blob4043447fdf2a9342185bb3de80176d3a622ed74a
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 deferred 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 cpp_opts->warn_deprecated = on;
771 break;
772
773 case OPT_Wdiv_by_zero:
774 warn_div_by_zero = on;
775 break;
776
777 case OPT_Weffcxx:
778 warn_ecpp = on;
779 break;
780
781 case OPT_Wendif_labels:
782 cpp_opts->warn_endif_labels = on;
783 break;
784
785 case OPT_Werror:
786 cpp_opts->warnings_are_errors = on;
787 break;
788
789 case OPT_Werror_implicit_function_decl:
790 if (!on)
791 result = 0;
792 else
793 mesg_implicit_function_declaration = 2;
794 break;
795
796 case OPT_Wfloat_equal:
797 warn_float_equal = on;
798 break;
799
800 case OPT_Wformat:
801 set_Wformat (on);
802 break;
803
804 case OPT_Wformat_eq:
805 set_Wformat (atoi (arg));
806 break;
807
808 case OPT_Wformat_extra_args:
809 warn_format_extra_args = on;
810 break;
811
812 case OPT_Wformat_nonliteral:
813 warn_format_nonliteral = on;
814 break;
815
816 case OPT_Wformat_security:
817 warn_format_security = on;
818 break;
819
820 case OPT_Wformat_y2k:
821 warn_format_y2k = on;
822 break;
823
824 case OPT_Wformat_zero_length:
825 warn_format_zero_length = on;
826 break;
827
828 case OPT_Wimplicit:
829 set_Wimplicit (on);
830 break;
831
832 case OPT_Wimplicit_function_decl:
833 mesg_implicit_function_declaration = on;
834 break;
835
836 case OPT_Wimplicit_int:
837 warn_implicit_int = on;
838 break;
839
840 case OPT_Wimport:
841 cpp_opts->warn_import = on;
842 break;
843
844 case OPT_Winvalid_pch:
845 cpp_opts->warn_invalid_pch = on;
846 break;
847
848 case OPT_Wlong_long:
849 warn_long_long = on;
850 break;
851
852 case OPT_Wmain:
853 if (on)
854 warn_main = 1;
855 else
856 warn_main = -1;
857 break;
858
859 case OPT_Wmissing_braces:
860 warn_missing_braces = on;
861 break;
862
863 case OPT_Wmissing_declarations:
864 warn_missing_declarations = on;
865 break;
866
867 case OPT_Wmissing_format_attribute:
868 warn_missing_format_attribute = on;
869 break;
870
871 case OPT_Wmissing_prototypes:
872 warn_missing_prototypes = on;
873 break;
874
875 case OPT_Wmultichar:
876 cpp_opts->warn_multichar = on;
877 break;
878
879 case OPT_Wnested_externs:
880 warn_nested_externs = on;
881 break;
882
883 case OPT_Wnon_template_friend:
884 warn_nontemplate_friend = on;
885 break;
886
887 case OPT_Wnon_virtual_dtor:
888 warn_nonvdtor = on;
889 break;
890
891 case OPT_Wnonnull:
892 warn_nonnull = on;
893 break;
894
895 case OPT_Wold_style_cast:
896 warn_old_style_cast = on;
897 break;
898
899 case OPT_Woverloaded_virtual:
900 warn_overloaded_virtual = on;
901 break;
902
903 case OPT_Wparentheses:
904 warn_parentheses = on;
905 break;
906
907 case OPT_Wpmf_conversions:
908 warn_pmf2ptr = on;
909 break;
910
911 case OPT_Wpointer_arith:
912 warn_pointer_arith = on;
913 break;
914
915 case OPT_Wprotocol:
916 warn_protocol = on;
917 break;
918
919 case OPT_Wselector:
920 warn_selector = on;
921 break;
922
923 case OPT_Wredundant_decls:
924 warn_redundant_decls = on;
925 break;
926
927 case OPT_Wreorder:
928 warn_reorder = on;
929 break;
930
931 case OPT_Wreturn_type:
932 warn_return_type = on;
933 break;
934
935 case OPT_Wsequence_point:
936 warn_sequence_point = on;
937 break;
938
939 case OPT_Wsign_compare:
940 warn_sign_compare = on;
941 break;
942
943 case OPT_Wsign_promo:
944 warn_sign_promo = on;
945 break;
946
947 case OPT_Wstrict_prototypes:
948 if (!on && c_language == clk_cplusplus)
949 warning ("-Wno-strict-prototypes is not supported in C++");
950 else
951 warn_strict_prototypes = on;
952 break;
953
954 case OPT_Wsynth:
955 warn_synth = on;
956 break;
957
958 case OPT_Wsystem_headers:
959 cpp_opts->warn_system_headers = on;
960 break;
961
962 case OPT_Wtraditional:
963 warn_traditional = on;
964 cpp_opts->warn_traditional = on;
965 break;
966
967 case OPT_Wtrigraphs:
968 cpp_opts->warn_trigraphs = on;
969 break;
970
971 case OPT_Wundeclared_selector:
972 warn_undeclared_selector = on;
973 break;
974
975 case OPT_Wundef:
976 cpp_opts->warn_undef = on;
977 break;
978
979 case OPT_Wunknown_pragmas:
980 /* Set to greater than 1, so that even unknown pragmas in
981 system headers will be warned about. */
982 warn_unknown_pragmas = on * 2;
983 break;
984
985 case OPT_Wunused_macros:
986 cpp_opts->warn_unused_macros = on;
987 break;
988
989 case OPT_Wwrite_strings:
990 if (c_language == clk_c)
991 flag_const_strings = on;
992 else
993 warn_write_strings = on;
994 break;
995
996 case OPT_ansi:
997 if (c_language == clk_c)
998 set_std_c89 (false, true);
999 else
1000 set_std_cxx98 (true);
1001 break;
1002
1003 case OPT_d:
1004 handle_OPT_d (arg);
1005 break;
1006
1007 case OPT_fcond_mismatch:
1008 if (c_language == clk_c)
1009 {
1010 flag_cond_mismatch = on;
1011 break;
1012 }
1013 /* Fall through. */
1014
1015 case OPT_fall_virtual:
1016 case OPT_fenum_int_equiv:
1017 case OPT_fguiding_decls:
1018 case OPT_fhonor_std:
1019 case OPT_fhuge_objects:
1020 case OPT_flabels_ok:
1021 case OPT_fname_mangling:
1022 case OPT_fnew_abi:
1023 case OPT_fnonnull_objects:
1024 case OPT_fsquangle:
1025 case OPT_fstrict_prototype:
1026 case OPT_fthis_is_variable:
1027 case OPT_fvtable_thunks:
1028 case OPT_fxref:
1029 warning ("switch \"%s\" is no longer supported", argv[0]);
1030 break;
1031
1032 case OPT_fabi_version:
1033 flag_abi_version = read_integral_parameter (arg, argv[0], 1);
1034 break;
1035
1036 case OPT_faccess_control:
1037 flag_access_control = on;
1038 break;
1039
1040 case OPT_falt_external_templates:
1041 flag_alt_external_templates = on;
1042 if (on)
1043 flag_external_templates = true;
1044 cp_deprecated:
1045 warning ("switch \"%s\" is deprecated, please see documentation for details", argv[0]);
1046 break;
1047
1048 case OPT_fasm:
1049 flag_no_asm = !on;
1050 break;
1051
1052 case OPT_fbuiltin:
1053 flag_no_builtin = !on;
1054 break;
1055
1056 case OPT_fbuiltin_:
1057 if (on)
1058 result = 0;
1059 else
1060 disable_builtin_function (arg);
1061 break;
1062
1063 case OPT_fdollars_in_identifiers:
1064 dollars_in_ident = on;
1065 break;
1066
1067 case OPT_fdump:
1068 if (!on || !dump_switch_p (argv[0] + strlen ("-f")))
1069 result = 0;
1070 break;
1071
1072 case OPT_ffreestanding:
1073 on = !on;
1074 /* Fall through... */
1075 case OPT_fhosted:
1076 flag_hosted = on;
1077 flag_no_builtin = !on;
1078 /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
1079 if (!on && warn_main == 2)
1080 warn_main = 0;
1081 break;
1082
1083 case OPT_fshort_double:
1084 flag_short_double = on;
1085 break;
1086
1087 case OPT_fshort_enums:
1088 flag_short_enums = on;
1089 break;
1090
1091 case OPT_fshort_wchar:
1092 flag_short_wchar = on;
1093 break;
1094
1095 case OPT_fsigned_bitfields:
1096 flag_signed_bitfields = on;
1097 explicit_flag_signed_bitfields = 1;
1098 break;
1099
1100 case OPT_fsigned_char:
1101 flag_signed_char = on;
1102 break;
1103
1104 case OPT_funsigned_bitfields:
1105 flag_signed_bitfields = !on;
1106 explicit_flag_signed_bitfields = 1;
1107 break;
1108
1109 case OPT_funsigned_char:
1110 flag_signed_char = !on;
1111 break;
1112
1113 case OPT_fcheck_new:
1114 flag_check_new = on;
1115 break;
1116
1117 case OPT_fconserve_space:
1118 flag_conserve_space = on;
1119 break;
1120
1121 case OPT_fconst_strings:
1122 flag_const_strings = on;
1123 break;
1124
1125 case OPT_fconstant_string_class:
1126 constant_string_class_name = arg;
1127 break;
1128
1129 case OPT_fdefault_inline:
1130 flag_default_inline = on;
1131 break;
1132
1133 case OPT_felide_constructors:
1134 flag_elide_constructors = on;
1135 break;
1136
1137 case OPT_fenforce_eh_specs:
1138 flag_enforce_eh_specs = on;
1139 break;
1140
1141 case OPT_fexternal_templates:
1142 flag_external_templates = on;
1143 goto cp_deprecated;
1144
1145 case OPT_ffor_scope:
1146 flag_new_for_scope = on;
1147 break;
1148
1149 case OPT_fgnu_keywords:
1150 flag_no_gnu_keywords = !on;
1151 break;
1152
1153 case OPT_fgnu_runtime:
1154 flag_next_runtime = !on;
1155 break;
1156
1157 case OPT_fhandle_exceptions:
1158 warning ("-fhandle-exceptions has been renamed to -fexceptions (and is now on by default)");
1159 flag_exceptions = on;
1160 break;
1161
1162 case OPT_fimplement_inlines:
1163 flag_implement_inlines = on;
1164 break;
1165
1166 case OPT_fimplicit_inline_templates:
1167 flag_implicit_inline_templates = on;
1168 break;
1169
1170 case OPT_fimplicit_templates:
1171 flag_implicit_templates = on;
1172 break;
1173
1174 case OPT_fms_extensions:
1175 flag_ms_extensions = on;
1176 break;
1177
1178 case OPT_fnext_runtime:
1179 flag_next_runtime = on;
1180 break;
1181
1182 case OPT_fnonansi_builtins:
1183 flag_no_nonansi_builtin = !on;
1184 break;
1185
1186 case OPT_foperator_names:
1187 cpp_opts->operator_names = on;
1188 break;
1189
1190 case OPT_foptional_diags:
1191 flag_optional_diags = on;
1192 break;
1193
1194 case OPT_fpch_deps:
1195 cpp_opts->restore_pch_deps = on;
1196 break;
1197
1198 case OPT_fpermissive:
1199 flag_permissive = on;
1200 break;
1201
1202 case OPT_fpreprocessed:
1203 cpp_opts->preprocessed = on;
1204 break;
1205
1206 case OPT_frepo:
1207 flag_use_repository = on;
1208 if (on)
1209 flag_implicit_templates = 0;
1210 break;
1211
1212 case OPT_frtti:
1213 flag_rtti = on;
1214 break;
1215
1216 case OPT_fshow_column:
1217 cpp_opts->show_column = on;
1218 break;
1219
1220 case OPT_fstats:
1221 flag_detailed_statistics = on;
1222 break;
1223
1224 case OPT_ftabstop:
1225 /* Don't recognize -fno-tabstop=. */
1226 if (!on)
1227 return 0;
1228
1229 /* It is documented that we silently ignore silly values. */
1230 {
1231 char *endptr;
1232 long tabstop = strtol (arg, &endptr, 10);
1233 if (*endptr == '\0' && tabstop >= 1 && tabstop <= 100)
1234 cpp_opts->tabstop = tabstop;
1235 }
1236 break;
1237
1238 case OPT_ftemplate_depth:
1239 max_tinst_depth = read_integral_parameter (arg, argv[0], 0);
1240 break;
1241
1242 case OPT_fvtable_gc:
1243 flag_vtable_gc = on;
1244 break;
1245
1246 case OPT_fuse_cxa_atexit:
1247 flag_use_cxa_atexit = on;
1248 break;
1249
1250 case OPT_fweak:
1251 flag_weak = on;
1252 break;
1253
1254 case OPT_gen_decls:
1255 flag_gen_declaration = 1;
1256 break;
1257
1258 case OPT_lang_asm:
1259 cpp_set_lang (parse_in, CLK_ASM);
1260 break;
1261
1262 case OPT_lang_objc:
1263 cpp_opts->objc = 1;
1264 break;
1265
1266 case OPT_nostdinc:
1267 /* No default include directories. You must specify all
1268 include-file directories with -I. */
1269 cpp_opts->no_standard_includes = 1;
1270 break;
1271
1272 case OPT_nostdincplusplus:
1273 /* No default C++-specific include directories. */
1274 cpp_opts->no_standard_cplusplus_includes = 1;
1275 break;
1276
1277 case OPT_o:
1278 if (!out_fname)
1279 out_fname = arg;
1280 else
1281 {
1282 error ("output filename specified twice");
1283 result = argc;
1284 }
1285 break;
1286
1287 /* We need to handle the -pedantic switches here, rather than in
1288 c_common_post_options, so that a subsequent -Wno-endif-labels
1289 is not overridden. */
1290 case OPT_pedantic_errors:
1291 cpp_opts->pedantic_errors = 1;
1292 /* fall through */
1293 case OPT_pedantic:
1294 cpp_opts->pedantic = 1;
1295 cpp_opts->warn_endif_labels = 1;
1296 break;
1297
1298 case OPT_print_objc_runtime_info:
1299 print_struct_values = 1;
1300 break;
1301
1302 case OPT_remap:
1303 cpp_opts->remap = 1;
1304 break;
1305
1306 case OPT_std_cplusplus98:
1307 case OPT_std_gnuplusplus98:
1308 set_std_cxx98 (code == OPT_std_cplusplus98 /* ISO */);
1309 break;
1310
1311 case OPT_std_c89:
1312 case OPT_std_iso9899_1990:
1313 case OPT_std_iso9899_199409:
1314 set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
1315 break;
1316
1317 case OPT_std_gnu89:
1318 set_std_c89 (false /* c94 */, false /* ISO */);
1319 break;
1320
1321 case OPT_std_c99:
1322 case OPT_std_c9x:
1323 case OPT_std_iso9899_1999:
1324 case OPT_std_iso9899_199x:
1325 set_std_c99 (true /* ISO */);
1326 break;
1327
1328 case OPT_std_gnu99:
1329 case OPT_std_gnu9x:
1330 set_std_c99 (false /* ISO */);
1331 break;
1332
1333 case OPT_trigraphs:
1334 cpp_opts->trigraphs = 1;
1335 break;
1336
1337 case OPT_traditional_cpp:
1338 cpp_opts->traditional = 1;
1339 break;
1340
1341 case OPT_undef:
1342 flag_undef = 1;
1343 break;
1344
1345 case OPT_w:
1346 cpp_opts->inhibit_warnings = 1;
1347 break;
1348
1349 case OPT_v:
1350 cpp_opts->verbose = 1;
1351 break;
1352 }
1353
1354 done:
1355 if (dup)
1356 free (dup);
1357 return result;
1358 }
1359
1360 /* Post-switch processing. */
1361 bool
1362 c_common_post_options ()
1363 {
1364 /* Canonicalize the input and output filenames. */
1365 if (in_fname == NULL || !strcmp (in_fname, "-"))
1366 in_fname = "";
1367
1368 if (out_fname == NULL || !strcmp (out_fname, "-"))
1369 out_fname = "";
1370
1371 if (cpp_opts->deps.style == DEPS_NONE)
1372 check_deps_environment_vars ();
1373
1374 handle_deferred_opts ();
1375
1376 sanitize_cpp_opts ();
1377
1378 flag_inline_trees = 1;
1379
1380 /* Use tree inlining if possible. Function instrumentation is only
1381 done in the RTL level, so we disable tree inlining. */
1382 if (! flag_instrument_function_entry_exit)
1383 {
1384 if (!flag_no_inline)
1385 flag_no_inline = 1;
1386 if (flag_inline_functions)
1387 {
1388 flag_inline_trees = 2;
1389 flag_inline_functions = 0;
1390 }
1391 }
1392
1393 /* Special format checking options don't work without -Wformat; warn if
1394 they are used. */
1395 if (warn_format_y2k && !warn_format)
1396 warning ("-Wformat-y2k ignored without -Wformat");
1397 if (warn_format_extra_args && !warn_format)
1398 warning ("-Wformat-extra-args ignored without -Wformat");
1399 if (warn_format_zero_length && !warn_format)
1400 warning ("-Wformat-zero-length ignored without -Wformat");
1401 if (warn_format_nonliteral && !warn_format)
1402 warning ("-Wformat-nonliteral ignored without -Wformat");
1403 if (warn_format_security && !warn_format)
1404 warning ("-Wformat-security ignored without -Wformat");
1405 if (warn_missing_format_attribute && !warn_format)
1406 warning ("-Wmissing-format-attribute ignored without -Wformat");
1407
1408 /* If an error has occurred in cpplib, note it so we fail
1409 immediately. */
1410 errorcount += cpp_errors (parse_in);
1411
1412 return flag_preprocess_only;
1413 }
1414
1415 /* Preprocess the input file to out_stream. */
1416 static void
1417 preprocess_file ()
1418 {
1419 /* Open the output now. We must do so even if no_output is on,
1420 because there may be other output than from the actual
1421 preprocessing (e.g. from -dM). */
1422 if (out_fname[0] == '\0')
1423 out_stream = stdout;
1424 else
1425 out_stream = fopen (out_fname, "w");
1426
1427 if (out_stream == NULL)
1428 fatal_io_error ("opening output file %s", out_fname);
1429 else
1430 cpp_preprocess_file (parse_in, in_fname, out_stream);
1431 }
1432
1433 /* Front end initialization common to C, ObjC and C++. */
1434 const char *
1435 c_common_init (filename)
1436 const char *filename;
1437 {
1438 /* Set up preprocessor arithmetic. Must be done after call to
1439 c_common_nodes_and_builtins for type nodes to be good. */
1440 cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
1441 cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
1442 cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
1443 cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
1444 cpp_opts->unsigned_wchar = TREE_UNSIGNED (wchar_type_node);
1445
1446 /* Register preprocessor built-ins before calls to
1447 cpp_main_file. */
1448 cpp_get_callbacks (parse_in)->register_builtins = cb_register_builtins;
1449
1450 /* NULL is passed up to toplev.c and we exit quickly. */
1451 if (flag_preprocess_only)
1452 {
1453 preprocess_file ();
1454 return NULL;
1455 }
1456
1457 /* Do this before initializing pragmas, as then cpplib's hash table
1458 has been set up. NOTE: we are using our own file name here, not
1459 the one supplied. */
1460 filename = init_c_lex (in_fname);
1461
1462 init_pragma ();
1463
1464 return filename;
1465 }
1466
1467 /* Common finish hook for the C, ObjC and C++ front ends. */
1468 void
1469 c_common_finish ()
1470 {
1471 FILE *deps_stream = NULL;
1472
1473 if (cpp_opts->deps.style != DEPS_NONE)
1474 {
1475 /* If -M or -MM was seen without -MF, default output to the
1476 output stream. */
1477 if (!deps_file)
1478 deps_stream = out_stream;
1479 else
1480 {
1481 deps_stream = fopen (deps_file, deps_append ? "a": "w");
1482 if (!deps_stream)
1483 fatal_io_error ("opening dependency file %s", deps_file);
1484 }
1485 }
1486
1487 /* For performance, avoid tearing down cpplib's internal structures
1488 with cpp_destroy (). */
1489 errorcount += cpp_finish (parse_in, deps_stream);
1490
1491 if (deps_stream && deps_stream != out_stream
1492 && (ferror (deps_stream) || fclose (deps_stream)))
1493 fatal_io_error ("closing dependency file %s", deps_file);
1494
1495 if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1496 fatal_io_error ("when writing output to %s", out_fname);
1497 }
1498
1499 /* Either of two environment variables can specify output of
1500 dependencies. Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1501 DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1502 and DEPS_TARGET is the target to mention in the deps. They also
1503 result in dependency information being appended to the output file
1504 rather than overwriting it, and like Sun's compiler
1505 SUNPRO_DEPENDENCIES suppresses the dependency on the main file. */
1506 static void
1507 check_deps_environment_vars ()
1508 {
1509 char *spec;
1510
1511 GET_ENVIRONMENT (spec, "DEPENDENCIES_OUTPUT");
1512 if (spec)
1513 cpp_opts->deps.style = DEPS_USER;
1514 else
1515 {
1516 GET_ENVIRONMENT (spec, "SUNPRO_DEPENDENCIES");
1517 if (spec)
1518 {
1519 cpp_opts->deps.style = DEPS_SYSTEM;
1520 cpp_opts->deps.ignore_main_file = true;
1521 }
1522 }
1523
1524 if (spec)
1525 {
1526 /* Find the space before the DEPS_TARGET, if there is one. */
1527 char *s = strchr (spec, ' ');
1528 if (s)
1529 {
1530 /* Let the caller perform MAKE quoting. */
1531 defer_opt (OPT_MT, s + 1);
1532 *s = '\0';
1533 }
1534
1535 /* Command line -MF overrides environment variables and default. */
1536 if (!deps_file)
1537 deps_file = spec;
1538
1539 deps_append = 1;
1540 }
1541 }
1542
1543 /* Handle deferred command line switches. */
1544 static void
1545 handle_deferred_opts ()
1546 {
1547 size_t i;
1548
1549 for (i = 0; i < deferred_count; i++)
1550 {
1551 struct deferred_opt *opt = &deferred_opts[i];
1552
1553 switch (opt->code)
1554 {
1555 case OPT_MT:
1556 case OPT_MQ:
1557 cpp_add_dependency_target (parse_in, opt->arg, opt->code == OPT_MQ);
1558 break;
1559
1560 default:
1561 abort ();
1562 }
1563 }
1564
1565 free (deferred_opts);
1566 }
1567
1568 /* These settings are appropriate for GCC, but not necessarily so for
1569 cpplib as a library. */
1570 static void
1571 sanitize_cpp_opts ()
1572 {
1573 /* If we don't know what style of dependencies to output, complain
1574 if any other dependency switches have been given. */
1575 if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
1576 error ("to generate dependencies you must specify either -M or -MM");
1577
1578 /* -dM and dependencies suppress normal output; do it here so that
1579 the last -d[MDN] switch overrides earlier ones. */
1580 if (cpp_opts->dump_macros == dump_only)
1581 cpp_opts->no_output = 1;
1582
1583 /* Disable -dD, -dN and -dI if normal output is suppressed. Allow
1584 -dM since at least glibc relies on -M -dM to work. */
1585 if (cpp_opts->no_output)
1586 {
1587 if (cpp_opts->dump_macros != dump_only)
1588 cpp_opts->dump_macros = dump_none;
1589 cpp_opts->dump_includes = 0;
1590 }
1591
1592 cpp_opts->unsigned_char = !flag_signed_char;
1593 cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1594
1595 /* We want -Wno-long-long to override -pedantic -std=non-c99
1596 and/or -Wtraditional, whatever the ordering. */
1597 cpp_opts->warn_long_long
1598 = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
1599 }
1600
1601 /* Set the C 89 standard (with 1994 amendments if C94, without GNU
1602 extensions if ISO). There is no concept of gnu94. */
1603 static void
1604 set_std_c89 (c94, iso)
1605 int c94, iso;
1606 {
1607 cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
1608 flag_iso = iso;
1609 flag_no_asm = iso;
1610 flag_no_gnu_keywords = iso;
1611 flag_no_nonansi_builtin = iso;
1612 flag_noniso_default_format_attributes = !iso;
1613 flag_isoc94 = c94;
1614 flag_isoc99 = 0;
1615 flag_writable_strings = 0;
1616 }
1617
1618 /* Set the C 99 standard (without GNU extensions if ISO). */
1619 static void
1620 set_std_c99 (iso)
1621 int iso;
1622 {
1623 cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1624 flag_no_asm = iso;
1625 flag_no_nonansi_builtin = iso;
1626 flag_noniso_default_format_attributes = !iso;
1627 flag_iso = iso;
1628 flag_isoc99 = 1;
1629 flag_isoc94 = 1;
1630 flag_writable_strings = 0;
1631 }
1632
1633 /* Set the C++ 98 standard (without GNU extensions if ISO). */
1634 static void
1635 set_std_cxx98 (iso)
1636 int iso;
1637 {
1638 cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1639 flag_no_gnu_keywords = iso;
1640 flag_no_nonansi_builtin = iso;
1641 flag_noniso_default_format_attributes = !iso;
1642 flag_iso = iso;
1643 }
1644
1645 /* Handle setting implicit to ON. */
1646 static void
1647 set_Wimplicit (on)
1648 int on;
1649 {
1650 warn_implicit = on;
1651 warn_implicit_int = on;
1652 if (on)
1653 {
1654 if (mesg_implicit_function_declaration != 2)
1655 mesg_implicit_function_declaration = 1;
1656 }
1657 else
1658 mesg_implicit_function_declaration = 0;
1659 }
1660
1661 /* Args to -d specify what to dump. Silently ignore
1662 unrecognized options; they may be aimed at toplev.c. */
1663 static void
1664 handle_OPT_d (arg)
1665 const char *arg;
1666 {
1667 char c;
1668
1669 while ((c = *arg++) != '\0')
1670 switch (c)
1671 {
1672 case 'M':
1673 cpp_opts->dump_macros = dump_only;
1674 break;
1675
1676 case 'N':
1677 cpp_opts->dump_macros = dump_names;
1678 break;
1679
1680 case 'D':
1681 cpp_opts->dump_macros = dump_definitions;
1682 break;
1683
1684 case 'I':
1685 cpp_opts->dump_includes = 1;
1686 break;
1687 }
1688 }
1689
1690 /* Write a slash-separated list of languages in FLAGS to BUF. */
1691 static void
1692 write_langs (buf, flags)
1693 char *buf;
1694 int flags;
1695 {
1696 *buf = '\0';
1697 if (flags & CL_C_ONLY)
1698 strcat (buf, "C");
1699 if (flags & CL_OBJC_ONLY)
1700 {
1701 if (*buf)
1702 strcat (buf, "/");
1703 strcat (buf, "ObjC");
1704 }
1705 if (flags & CL_CXX_ONLY)
1706 {
1707 if (*buf)
1708 strcat (buf, "/");
1709 strcat (buf, "C++");
1710 }
1711 }
1712
1713 /* Complain that switch OPT_INDEX does not apply to this front end. */
1714 static void
1715 complain_wrong_lang (opt_index)
1716 size_t opt_index;
1717 {
1718 char ok_langs[60], bad_langs[60];
1719 int ok_flags = cl_options[opt_index].flags;
1720
1721 write_langs (ok_langs, ok_flags);
1722 write_langs (bad_langs, ~ok_flags);
1723 warning ("\"-%s\" is valid for %s but not for %s",
1724 cl_options[opt_index].opt_text, ok_langs, bad_langs);
1725 }
1726
1727 /* Handle --help output. */
1728 static void
1729 print_help ()
1730 {
1731 /* To keep the lines from getting too long for some compilers, limit
1732 to about 500 characters (6 lines) per chunk. */
1733 fputs (_("\
1734 Switches:\n\
1735 -include <file> Include the contents of <file> before other files\n\
1736 -imacros <file> Accept definition of macros in <file>\n\
1737 -iprefix <path> Specify <path> as a prefix for next two options\n\
1738 -iwithprefix <dir> Add <dir> to the end of the system include path\n\
1739 -iwithprefixbefore <dir> Add <dir> to the end of the main include path\n\
1740 -isystem <dir> Add <dir> to the start of the system include path\n\
1741 "), stdout);
1742 fputs (_("\
1743 -idirafter <dir> Add <dir> to the end of the system include path\n\
1744 -I <dir> Add <dir> to the end of the main include path\n\
1745 -I- Fine-grained include path control; see info docs\n\
1746 -nostdinc Do not search system include directories\n\
1747 (dirs specified with -isystem will still be used)\n\
1748 -nostdinc++ Do not search system include directories for C++\n\
1749 -o <file> Put output into <file>\n\
1750 "), stdout);
1751 fputs (_("\
1752 -trigraphs Support ISO C trigraphs\n\
1753 -std=<std name> Specify the conformance standard; one of:\n\
1754 gnu89, gnu99, c89, c99, iso9899:1990,\n\
1755 iso9899:199409, iso9899:1999, c++98\n\
1756 -w Inhibit warning messages\n\
1757 -W[no-]trigraphs Warn if trigraphs are encountered\n\
1758 -W[no-]comment{s} Warn if one comment starts inside another\n\
1759 "), stdout);
1760 fputs (_("\
1761 -W[no-]traditional Warn about features not present in traditional C\n\
1762 -W[no-]undef Warn if an undefined macro is used by #if\n\
1763 -W[no-]import Warn about the use of the #import directive\n\
1764 "), stdout);
1765 fputs (_("\
1766 -W[no-]error Treat all warnings as errors\n\
1767 -W[no-]system-headers Do not suppress warnings from system headers\n\
1768 -W[no-]all Enable most preprocessor warnings\n\
1769 "), stdout);
1770 fputs (_("\
1771 -M Generate make dependencies\n\
1772 -MM As -M, but ignore system header files\n\
1773 -MD Generate make dependencies and compile\n\
1774 -MMD As -MD, but ignore system header files\n\
1775 -MF <file> Write dependency output to the given file\n\
1776 -MG Treat missing header file as generated files\n\
1777 "), stdout);
1778 fputs (_("\
1779 -MP Generate phony targets for all headers\n\
1780 -MQ <target> Add a MAKE-quoted target\n\
1781 -MT <target> Add an unquoted target\n\
1782 "), stdout);
1783 fputs (_("\
1784 -D<macro> Define a <macro> with string '1' as its value\n\
1785 -D<macro>=<val> Define a <macro> with <val> as its value\n\
1786 -A<question>=<answer> Assert the <answer> to <question>\n\
1787 -A-<question>=<answer> Disable the <answer> to <question>\n\
1788 -U<macro> Undefine <macro> \n\
1789 -v Display the version number\n\
1790 "), stdout);
1791 fputs (_("\
1792 -H Print the name of header files as they are used\n\
1793 -C Do not discard comments\n\
1794 -dM Display a list of macro definitions active at end\n\
1795 -dD Preserve macro definitions in output\n\
1796 -dN As -dD except that only the names are preserved\n\
1797 -dI Include #include directives in the output\n\
1798 "), stdout);
1799 fputs (_("\
1800 -f[no-]preprocessed Treat the input file as already preprocessed\n\
1801 -ftabstop=<number> Distance between tab stops for column reporting\n\
1802 -P Do not generate #line directives\n\
1803 -remap Remap file names when including files\n\
1804 --help Display this information\n\
1805 "), stdout);
1806 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org