fold-const.c (fold_binary_loc): Fix copy-and-pasto.
[gcc.git] / gcc / opts-global.c
1 /* Command line option handling. Code involving global state that
2 should not be shared with the driver.
3 Copyright (C) 2002-2014 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
20
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "diagnostic.h"
25 #include "opts.h"
26 #include "flags.h"
27 #include "tree.h" /* Required by langhooks.h. */
28 #include "basic-block.h"
29 #include "tree-ssa-alias.h"
30 #include "internal-fn.h"
31 #include "gimple-expr.h"
32 #include "is-a.h"
33 #include "gimple.h"
34 #include "langhooks.h"
35 #include "tm.h" /* Required by rtl.h. */
36 #include "rtl.h"
37 #include "dbgcnt.h"
38 #include "debug.h"
39 #include "lto-streamer.h"
40 #include "output.h"
41 #include "plugin.h"
42 #include "toplev.h"
43 #include "tree-pass.h"
44 #include "context.h"
45
46 typedef const char *const_char_p; /* For DEF_VEC_P. */
47
48 static vec<const_char_p> ignored_options;
49
50 /* Input file names. */
51 const char **in_fnames;
52 unsigned num_in_fnames;
53
54 /* Return a malloced slash-separated list of languages in MASK. */
55
56 static char *
57 write_langs (unsigned int mask)
58 {
59 unsigned int n = 0, len = 0;
60 const char *lang_name;
61 char *result;
62
63 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
64 if (mask & (1U << n))
65 len += strlen (lang_name) + 1;
66
67 result = XNEWVEC (char, len);
68 len = 0;
69 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
70 if (mask & (1U << n))
71 {
72 if (len)
73 result[len++] = '/';
74 strcpy (result + len, lang_name);
75 len += strlen (lang_name);
76 }
77
78 result[len] = 0;
79
80 return result;
81 }
82
83 /* Complain that switch DECODED does not apply to this front end (mask
84 LANG_MASK). */
85
86 static void
87 complain_wrong_lang (const struct cl_decoded_option *decoded,
88 unsigned int lang_mask)
89 {
90 const struct cl_option *option = &cl_options[decoded->opt_index];
91 const char *text = decoded->orig_option_with_args_text;
92 char *ok_langs = NULL, *bad_lang = NULL;
93 unsigned int opt_flags = option->flags;
94
95 if (!lang_hooks.complain_wrong_lang_p (option))
96 return;
97
98 opt_flags &= ((1U << cl_lang_count) - 1) | CL_DRIVER;
99 if (opt_flags != CL_DRIVER)
100 ok_langs = write_langs (opt_flags);
101 if (lang_mask != CL_DRIVER)
102 bad_lang = write_langs (lang_mask);
103
104 if (opt_flags == CL_DRIVER)
105 error ("command line option %qs is valid for the driver but not for %s",
106 text, bad_lang);
107 else if (lang_mask == CL_DRIVER)
108 gcc_unreachable ();
109 else
110 /* Eventually this should become a hard error IMO. */
111 warning (0, "command line option %qs is valid for %s but not for %s",
112 text, ok_langs, bad_lang);
113
114 free (ok_langs);
115 free (bad_lang);
116 }
117
118 /* Buffer the unknown option described by the string OPT. Currently,
119 we only complain about unknown -Wno-* options if they may have
120 prevented a diagnostic. Otherwise, we just ignore them. Note that
121 if we do complain, it is only as a warning, not an error; passing
122 the compiler an unrecognised -Wno-* option should never change
123 whether the compilation succeeds or fails. */
124
125 static void
126 postpone_unknown_option_warning (const char *opt)
127 {
128 ignored_options.safe_push (opt);
129 }
130
131 /* Produce a warning for each option previously buffered. */
132
133 void
134 print_ignored_options (void)
135 {
136 while (!ignored_options.is_empty ())
137 {
138 const char *opt;
139
140 opt = ignored_options.pop ();
141 warning_at (UNKNOWN_LOCATION, 0,
142 "unrecognized command line option \"%s\"", opt);
143 }
144 }
145
146 /* Handle an unknown option DECODED, returning true if an error should
147 be given. */
148
149 static bool
150 unknown_option_callback (const struct cl_decoded_option *decoded)
151 {
152 const char *opt = decoded->arg;
153
154 if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
155 && !(decoded->errors & CL_ERR_NEGATIVE))
156 {
157 /* We don't generate warnings for unknown -Wno-* options unless
158 we issue diagnostics. */
159 postpone_unknown_option_warning (opt);
160 return false;
161 }
162 else
163 return true;
164 }
165
166 /* Handle a front-end option; arguments and return value as for
167 handle_option. */
168
169 static bool
170 lang_handle_option (struct gcc_options *opts,
171 struct gcc_options *opts_set,
172 const struct cl_decoded_option *decoded,
173 unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
174 location_t loc,
175 const struct cl_option_handlers *handlers,
176 diagnostic_context *dc)
177 {
178 gcc_assert (opts == &global_options);
179 gcc_assert (opts_set == &global_options_set);
180 gcc_assert (dc == global_dc);
181 gcc_assert (decoded->canonical_option_num_elements <= 2);
182 return lang_hooks.handle_option (decoded->opt_index, decoded->arg,
183 decoded->value, kind, loc, handlers);
184 }
185
186 /* Handle FILENAME from the command line. */
187
188 static void
189 add_input_filename (const char *filename)
190 {
191 num_in_fnames++;
192 in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
193 in_fnames[num_in_fnames - 1] = filename;
194 }
195
196 /* Handle the vector of command line options (located at LOC), storing
197 the results of processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT
198 in OPTS and OPTS_SET and using DC for diagnostic state. LANG_MASK
199 contains has a single bit set representing the current language.
200 HANDLERS describes what functions to call for the options. */
201
202 static void
203 read_cmdline_options (struct gcc_options *opts, struct gcc_options *opts_set,
204 struct cl_decoded_option *decoded_options,
205 unsigned int decoded_options_count,
206 location_t loc,
207 unsigned int lang_mask,
208 const struct cl_option_handlers *handlers,
209 diagnostic_context *dc)
210 {
211 unsigned int i;
212
213 for (i = 1; i < decoded_options_count; i++)
214 {
215 if (decoded_options[i].opt_index == OPT_SPECIAL_input_file)
216 {
217 /* Input files should only ever appear on the main command
218 line. */
219 gcc_assert (opts == &global_options);
220 gcc_assert (opts_set == &global_options_set);
221
222 if (opts->x_main_input_filename == NULL)
223 {
224 opts->x_main_input_filename = decoded_options[i].arg;
225 opts->x_main_input_baselength
226 = base_of_path (opts->x_main_input_filename,
227 &opts->x_main_input_basename);
228 }
229 add_input_filename (decoded_options[i].arg);
230 continue;
231 }
232
233 read_cmdline_option (opts, opts_set,
234 decoded_options + i, loc, lang_mask, handlers,
235 dc);
236 }
237 }
238
239 /* Language mask determined at initialization. */
240 static unsigned int initial_lang_mask;
241
242 /* Initialize global options-related settings at start-up. */
243
244 void
245 init_options_once (void)
246 {
247 /* Perform language-specific options initialization. */
248 initial_lang_mask = lang_hooks.option_lang_mask ();
249
250 lang_hooks.initialize_diagnostics (global_dc);
251 }
252
253 /* Decode command-line options to an array, like
254 decode_cmdline_options_to_array and with the same arguments but
255 using the default lang_mask. */
256
257 void
258 decode_cmdline_options_to_array_default_mask (unsigned int argc,
259 const char **argv,
260 struct cl_decoded_option **decoded_options,
261 unsigned int *decoded_options_count)
262 {
263 decode_cmdline_options_to_array (argc, argv,
264 initial_lang_mask | CL_COMMON | CL_TARGET,
265 decoded_options, decoded_options_count);
266 }
267
268 /* Set *HANDLERS to the default set of option handlers for use in the
269 compilers proper (not the driver). */
270 void
271 set_default_handlers (struct cl_option_handlers *handlers)
272 {
273 handlers->unknown_option_callback = unknown_option_callback;
274 handlers->wrong_lang_callback = complain_wrong_lang;
275 handlers->num_handlers = 3;
276 handlers->handlers[0].handler = lang_handle_option;
277 handlers->handlers[0].mask = initial_lang_mask;
278 handlers->handlers[1].handler = common_handle_option;
279 handlers->handlers[1].mask = CL_COMMON;
280 handlers->handlers[2].handler = target_handle_option;
281 handlers->handlers[2].mask = CL_TARGET;
282 }
283
284 /* Parse command line options and set default flag values. Do minimal
285 options processing. The decoded options are in *DECODED_OPTIONS
286 and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC;
287 the options are located at LOC. */
288 void
289 decode_options (struct gcc_options *opts, struct gcc_options *opts_set,
290 struct cl_decoded_option *decoded_options,
291 unsigned int decoded_options_count,
292 location_t loc, diagnostic_context *dc)
293 {
294 struct cl_option_handlers handlers;
295
296 unsigned int lang_mask;
297
298 lang_mask = initial_lang_mask;
299
300 set_default_handlers (&handlers);
301
302 default_options_optimization (opts, opts_set,
303 decoded_options, decoded_options_count,
304 loc, lang_mask, &handlers, dc);
305
306 read_cmdline_options (opts, opts_set,
307 decoded_options, decoded_options_count,
308 loc, lang_mask,
309 &handlers, dc);
310
311 finish_options (opts, opts_set, loc);
312 }
313
314 /* Process common options that have been deferred until after the
315 handlers have been called for all options. */
316
317 void
318 handle_common_deferred_options (void)
319 {
320 unsigned int i;
321 cl_deferred_option *opt;
322 vec<cl_deferred_option> v;
323
324 if (common_deferred_options)
325 v = *((vec<cl_deferred_option> *) common_deferred_options);
326 else
327 v = vNULL;
328
329 if (flag_dump_all_passed)
330 enable_rtl_dump_file ();
331
332 if (flag_opt_info)
333 opt_info_switch_p (NULL);
334
335 FOR_EACH_VEC_ELT (v, i, opt)
336 {
337 switch (opt->opt_index)
338 {
339 case OPT_fcall_used_:
340 fix_register (opt->arg, 0, 1);
341 break;
342
343 case OPT_fcall_saved_:
344 fix_register (opt->arg, 0, 0);
345 break;
346
347 case OPT_fdbg_cnt_:
348 dbg_cnt_process_opt (opt->arg);
349 break;
350
351 case OPT_fdbg_cnt_list:
352 dbg_cnt_list_all_counters ();
353 break;
354
355 case OPT_fdebug_prefix_map_:
356 add_debug_prefix_map (opt->arg);
357 break;
358
359 case OPT_fdump_:
360 if (!g->get_dumps ()->dump_switch_p (opt->arg))
361 error ("unrecognized command line option %<-fdump-%s%>", opt->arg);
362 break;
363
364 case OPT_fopt_info_:
365 if (!opt_info_switch_p (opt->arg))
366 error ("unrecognized command line option %<-fopt-info-%s%>",
367 opt->arg);
368 break;
369
370 case OPT_fenable_:
371 case OPT_fdisable_:
372 if (opt->opt_index == OPT_fenable_)
373 enable_pass (opt->arg);
374 else
375 disable_pass (opt->arg);
376 break;
377
378 case OPT_ffixed_:
379 /* Deferred. */
380 fix_register (opt->arg, 1, 1);
381 break;
382
383 case OPT_fplugin_:
384 #ifdef ENABLE_PLUGIN
385 add_new_plugin (opt->arg);
386 #else
387 error ("plugin support is disabled; configure with --enable-plugin");
388 #endif
389 break;
390
391 case OPT_fplugin_arg_:
392 #ifdef ENABLE_PLUGIN
393 parse_plugin_arg_opt (opt->arg);
394 #else
395 error ("plugin support is disabled; configure with --enable-plugin");
396 #endif
397 break;
398
399 case OPT_frandom_seed:
400 /* The real switch is -fno-random-seed. */
401 if (!opt->value)
402 set_random_seed (NULL);
403 break;
404
405 case OPT_frandom_seed_:
406 set_random_seed (opt->arg);
407 break;
408
409 case OPT_fstack_limit:
410 /* The real switch is -fno-stack-limit. */
411 if (!opt->value)
412 stack_limit_rtx = NULL_RTX;
413 break;
414
415 case OPT_fstack_limit_register_:
416 {
417 int reg = decode_reg_name (opt->arg);
418 if (reg < 0)
419 error ("unrecognized register name %qs", opt->arg);
420 else
421 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
422 }
423 break;
424
425 case OPT_fstack_limit_symbol_:
426 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (opt->arg));
427 break;
428
429 default:
430 gcc_unreachable ();
431 }
432 }
433 }