1 /* Command line option handling. Code involving global state that
2 should not be shared with the driver.
3 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
25 #include "diagnostic.h"
29 #include "tree.h" /* Required by langhooks.h. */
30 #include "langhooks.h"
31 #include "tm.h" /* Required by rtl.h. */
33 #include "lto-streamer.h"
37 #include "tree-pass.h"
39 typedef const char *const_char_p
; /* For DEF_VEC_P. */
40 DEF_VEC_P(const_char_p
);
41 DEF_VEC_ALLOC_P(const_char_p
,heap
);
43 static VEC(const_char_p
,heap
) *ignored_options
;
45 /* Input file names. */
46 const char **in_fnames
;
47 unsigned num_in_fnames
;
49 /* Return a malloced slash-separated list of languages in MASK. */
52 write_langs (unsigned int mask
)
54 unsigned int n
= 0, len
= 0;
55 const char *lang_name
;
58 for (n
= 0; (lang_name
= lang_names
[n
]) != 0; n
++)
60 len
+= strlen (lang_name
) + 1;
62 result
= XNEWVEC (char, len
);
64 for (n
= 0; (lang_name
= lang_names
[n
]) != 0; n
++)
69 strcpy (result
+ len
, lang_name
);
70 len
+= strlen (lang_name
);
78 /* Complain that switch DECODED does not apply to this front end (mask
82 complain_wrong_lang (const struct cl_decoded_option
*decoded
,
83 unsigned int lang_mask
)
85 const struct cl_option
*option
= &cl_options
[decoded
->opt_index
];
86 const char *text
= decoded
->orig_option_with_args_text
;
87 char *ok_langs
= NULL
, *bad_lang
= NULL
;
88 unsigned int opt_flags
= option
->flags
;
90 if (!lang_hooks
.complain_wrong_lang_p (option
))
93 opt_flags
&= ((1U << cl_lang_count
) - 1) | CL_DRIVER
;
94 if (opt_flags
!= CL_DRIVER
)
95 ok_langs
= write_langs (opt_flags
);
96 if (lang_mask
!= CL_DRIVER
)
97 bad_lang
= write_langs (lang_mask
);
99 if (opt_flags
== CL_DRIVER
)
100 error ("command line option %qs is valid for the driver but not for %s",
102 else if (lang_mask
== CL_DRIVER
)
105 /* Eventually this should become a hard error IMO. */
106 warning (0, "command line option %qs is valid for %s but not for %s",
107 text
, ok_langs
, bad_lang
);
113 /* Buffer the unknown option described by the string OPT. Currently,
114 we only complain about unknown -Wno-* options if they may have
115 prevented a diagnostic. Otherwise, we just ignore them. Note that
116 if we do complain, it is only as a warning, not an error; passing
117 the compiler an unrecognised -Wno-* option should never change
118 whether the compilation succeeds or fails. */
121 postpone_unknown_option_warning (const char *opt
)
123 VEC_safe_push (const_char_p
, heap
, ignored_options
, opt
);
126 /* Produce a warning for each option previously buffered. */
129 print_ignored_options (void)
131 while (!VEC_empty (const_char_p
, ignored_options
))
135 opt
= VEC_pop (const_char_p
, ignored_options
);
136 warning_at (UNKNOWN_LOCATION
, 0,
137 "unrecognized command line option \"%s\"", opt
);
141 /* Handle an unknown option DECODED, returning true if an error should
145 unknown_option_callback (const struct cl_decoded_option
*decoded
)
147 const char *opt
= decoded
->arg
;
149 if (opt
[1] == 'W' && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-'
150 && !(decoded
->errors
& CL_ERR_NEGATIVE
))
152 /* We don't generate warnings for unknown -Wno-* options unless
153 we issue diagnostics. */
154 postpone_unknown_option_warning (opt
);
161 /* Note that an option DECODED has been successfully handled with a
162 handler for mask MASK. */
165 post_handling_callback (const struct cl_decoded_option
*decoded ATTRIBUTE_UNUSED
,
166 unsigned int mask ATTRIBUTE_UNUSED
)
169 lto_register_user_option (decoded
->opt_index
, decoded
->arg
,
170 decoded
->value
, mask
);
174 /* Handle a front-end option; arguments and return value as for
178 lang_handle_option (struct gcc_options
*opts
,
179 struct gcc_options
*opts_set
,
180 const struct cl_decoded_option
*decoded
,
181 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
183 const struct cl_option_handlers
*handlers
,
184 diagnostic_context
*dc
)
186 gcc_assert (opts
== &global_options
);
187 gcc_assert (opts_set
== &global_options_set
);
188 gcc_assert (dc
== global_dc
);
189 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
190 return lang_hooks
.handle_option (decoded
->opt_index
, decoded
->arg
,
191 decoded
->value
, kind
, loc
, handlers
);
194 /* Handle FILENAME from the command line. */
197 add_input_filename (const char *filename
)
200 in_fnames
= XRESIZEVEC (const char *, in_fnames
, num_in_fnames
);
201 in_fnames
[num_in_fnames
- 1] = filename
;
204 /* Handle the vector of command line options (located at LOC), storing
205 the results of processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT
206 in OPTS and OPTS_SET and using DC for diagnostic state. LANG_MASK
207 contains has a single bit set representing the current language.
208 HANDLERS describes what functions to call for the options. */
211 read_cmdline_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
212 struct cl_decoded_option
*decoded_options
,
213 unsigned int decoded_options_count
,
215 unsigned int lang_mask
,
216 const struct cl_option_handlers
*handlers
,
217 diagnostic_context
*dc
)
221 for (i
= 1; i
< decoded_options_count
; i
++)
223 if (decoded_options
[i
].opt_index
== OPT_SPECIAL_input_file
)
225 /* Input files should only ever appear on the main command
227 gcc_assert (opts
== &global_options
);
228 gcc_assert (opts_set
== &global_options_set
);
230 if (main_input_filename
== NULL
)
232 main_input_filename
= decoded_options
[i
].arg
;
233 main_input_baselength
234 = base_of_path (main_input_filename
, &main_input_basename
);
236 add_input_filename (decoded_options
[i
].arg
);
240 read_cmdline_option (opts
, opts_set
,
241 decoded_options
+ i
, loc
, lang_mask
, handlers
,
246 /* Language mask determined at initialization. */
247 static unsigned int initial_lang_mask
;
249 /* Initialize global options-related settings at start-up. */
252 init_options_once (void)
254 /* Perform language-specific options initialization. */
255 initial_lang_mask
= lang_hooks
.option_lang_mask ();
257 lang_hooks
.initialize_diagnostics (global_dc
);
260 /* Decode command-line options to an array, like
261 decode_cmdline_options_to_array and with the same arguments but
262 using the default lang_mask. */
265 decode_cmdline_options_to_array_default_mask (unsigned int argc
,
267 struct cl_decoded_option
**decoded_options
,
268 unsigned int *decoded_options_count
)
270 decode_cmdline_options_to_array (argc
, argv
,
271 initial_lang_mask
| CL_COMMON
| CL_TARGET
,
272 decoded_options
, decoded_options_count
);
275 /* Set *HANDLERS to the default set of option handlers for use in the
276 compilers proper (not the driver). */
278 set_default_handlers (struct cl_option_handlers
*handlers
)
280 handlers
->unknown_option_callback
= unknown_option_callback
;
281 handlers
->wrong_lang_callback
= complain_wrong_lang
;
282 handlers
->post_handling_callback
= post_handling_callback
;
283 handlers
->num_handlers
= 3;
284 handlers
->handlers
[0].handler
= lang_handle_option
;
285 handlers
->handlers
[0].mask
= initial_lang_mask
;
286 handlers
->handlers
[1].handler
= common_handle_option
;
287 handlers
->handlers
[1].mask
= CL_COMMON
;
288 handlers
->handlers
[2].handler
= target_handle_option
;
289 handlers
->handlers
[2].mask
= CL_TARGET
;
292 /* Parse command line options and set default flag values. Do minimal
293 options processing. The decoded options are in *DECODED_OPTIONS
294 and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC;
295 the options are located at LOC. */
297 decode_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
298 struct cl_decoded_option
*decoded_options
,
299 unsigned int decoded_options_count
,
300 location_t loc
, diagnostic_context
*dc
)
302 struct cl_option_handlers handlers
;
304 unsigned int lang_mask
;
306 lang_mask
= initial_lang_mask
;
308 set_default_handlers (&handlers
);
310 /* Enable -Werror=coverage-mismatch by default. */
311 control_warning_option (OPT_Wcoverage_mismatch
, (int) DK_ERROR
, true,
313 &handlers
, opts
, opts_set
, dc
);
315 default_options_optimization (opts
, opts_set
,
316 decoded_options
, decoded_options_count
,
317 loc
, lang_mask
, &handlers
, dc
);
320 /* Clear any options currently held for LTO. */
321 lto_clear_user_options ();
324 read_cmdline_options (opts
, opts_set
,
325 decoded_options
, decoded_options_count
,
329 finish_options (opts
, opts_set
);
332 /* Process common options that have been deferred until after the
333 handlers have been called for all options. */
336 handle_common_deferred_options (void)
339 cl_deferred_option
*opt
;
340 VEC(cl_deferred_option
,heap
) *vec
341 = (VEC(cl_deferred_option
,heap
) *) common_deferred_options
;
343 FOR_EACH_VEC_ELT (cl_deferred_option
, vec
, i
, opt
)
345 switch (opt
->opt_index
)
347 case OPT_fcall_used_
:
348 fix_register (opt
->arg
, 0, 1);
351 case OPT_fcall_saved_
:
352 fix_register (opt
->arg
, 0, 0);
356 if (!dump_switch_p (opt
->arg
))
357 error ("unrecognized command line option %<-fdump-%s%>", opt
->arg
);
362 fix_register (opt
->arg
, 1, 1);
367 add_new_plugin (opt
->arg
);
369 error ("plugin support is disabled; configure with --enable-plugin");
373 case OPT_fplugin_arg_
:
375 parse_plugin_arg_opt (opt
->arg
);
377 error ("plugin support is disabled; configure with --enable-plugin");
381 case OPT_fstack_limit
:
382 /* The real switch is -fno-stack-limit. */
383 gcc_assert (!opt
->value
);
384 stack_limit_rtx
= NULL_RTX
;
387 case OPT_fstack_limit_register_
:
389 int reg
= decode_reg_name (opt
->arg
);
391 error ("unrecognized register name %qs", opt
->arg
);
393 stack_limit_rtx
= gen_rtx_REG (Pmode
, reg
);
397 case OPT_fstack_limit_symbol_
:
398 stack_limit_rtx
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (opt
->arg
));