Daily bump.
[official-gcc.git] / gcc / opts.c
blob0a49bc0b32fbaf6bfb5158334826d74dc1121cd4
1 /* Command line option handling.
2 Copyright (C) 2002-2014 Free Software Foundation, Inc.
3 Contributed by Neil Booth.
5 This file is part of GCC.
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.
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.
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/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "intl.h"
24 #include "coretypes.h"
25 #include "opts.h"
26 #include "options.h"
27 #include "tm.h" /* For STACK_CHECK_BUILTIN,
28 STACK_CHECK_STATIC_BUILTIN, DEFAULT_GDB_EXTENSIONS,
29 DWARF2_DEBUGGING_INFO and DBX_DEBUGGING_INFO. */
30 #include "flags.h"
31 #include "params.h"
32 #include "diagnostic.h"
33 #include "diagnostic-color.h"
34 #include "opts-diagnostic.h"
35 #include "insn-attr-common.h"
36 #include "common/common-target.h"
38 static void set_Wstrict_aliasing (struct gcc_options *opts, int onoff);
40 /* Indexed by enum debug_info_type. */
41 const char *const debug_type_names[] =
43 "none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
46 /* Parse the -femit-struct-debug-detailed option value
47 and set the flag variables. */
49 #define MATCH( prefix, string ) \
50 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
51 ? ((string += sizeof prefix - 1), 1) : 0)
53 void
54 set_struct_debug_option (struct gcc_options *opts, location_t loc,
55 const char *spec)
57 /* various labels for comparison */
58 static const char dfn_lbl[] = "dfn:", dir_lbl[] = "dir:", ind_lbl[] = "ind:";
59 static const char ord_lbl[] = "ord:", gen_lbl[] = "gen:";
60 static const char none_lbl[] = "none", any_lbl[] = "any";
61 static const char base_lbl[] = "base", sys_lbl[] = "sys";
63 enum debug_struct_file files = DINFO_STRUCT_FILE_ANY;
64 /* Default is to apply to as much as possible. */
65 enum debug_info_usage usage = DINFO_USAGE_NUM_ENUMS;
66 int ord = 1, gen = 1;
68 /* What usage? */
69 if (MATCH (dfn_lbl, spec))
70 usage = DINFO_USAGE_DFN;
71 else if (MATCH (dir_lbl, spec))
72 usage = DINFO_USAGE_DIR_USE;
73 else if (MATCH (ind_lbl, spec))
74 usage = DINFO_USAGE_IND_USE;
76 /* Generics or not? */
77 if (MATCH (ord_lbl, spec))
78 gen = 0;
79 else if (MATCH (gen_lbl, spec))
80 ord = 0;
82 /* What allowable environment? */
83 if (MATCH (none_lbl, spec))
84 files = DINFO_STRUCT_FILE_NONE;
85 else if (MATCH (any_lbl, spec))
86 files = DINFO_STRUCT_FILE_ANY;
87 else if (MATCH (sys_lbl, spec))
88 files = DINFO_STRUCT_FILE_SYS;
89 else if (MATCH (base_lbl, spec))
90 files = DINFO_STRUCT_FILE_BASE;
91 else
92 error_at (loc,
93 "argument %qs to %<-femit-struct-debug-detailed%> "
94 "not recognized",
95 spec);
97 /* Effect the specification. */
98 if (usage == DINFO_USAGE_NUM_ENUMS)
100 if (ord)
102 opts->x_debug_struct_ordinary[DINFO_USAGE_DFN] = files;
103 opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE] = files;
104 opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE] = files;
106 if (gen)
108 opts->x_debug_struct_generic[DINFO_USAGE_DFN] = files;
109 opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE] = files;
110 opts->x_debug_struct_generic[DINFO_USAGE_IND_USE] = files;
113 else
115 if (ord)
116 opts->x_debug_struct_ordinary[usage] = files;
117 if (gen)
118 opts->x_debug_struct_generic[usage] = files;
121 if (*spec == ',')
122 set_struct_debug_option (opts, loc, spec+1);
123 else
125 /* No more -femit-struct-debug-detailed specifications.
126 Do final checks. */
127 if (*spec != '\0')
128 error_at (loc,
129 "argument %qs to %<-femit-struct-debug-detailed%> unknown",
130 spec);
131 if (opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE]
132 < opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE]
133 || opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE]
134 < opts->x_debug_struct_generic[DINFO_USAGE_IND_USE])
135 error_at (loc,
136 "%<-femit-struct-debug-detailed=dir:...%> must allow "
137 "at least as much as "
138 "%<-femit-struct-debug-detailed=ind:...%>");
142 /* Strip off a legitimate source ending from the input string NAME of
143 length LEN. Rather than having to know the names used by all of
144 our front ends, we strip off an ending of a period followed by
145 up to five characters. (Java uses ".class".) */
147 void
148 strip_off_ending (char *name, int len)
150 int i;
151 for (i = 2; i < 6 && len > i; i++)
153 if (name[len - i] == '.')
155 name[len - i] = '\0';
156 break;
161 /* Find the base name of a path, stripping off both directories and
162 a single final extension. */
164 base_of_path (const char *path, const char **base_out)
166 const char *base = path;
167 const char *dot = 0;
168 const char *p = path;
169 char c = *p;
170 while (c)
172 if (IS_DIR_SEPARATOR (c))
174 base = p + 1;
175 dot = 0;
177 else if (c == '.')
178 dot = p;
179 c = *++p;
181 if (!dot)
182 dot = p;
183 *base_out = base;
184 return dot - base;
187 /* What to print when a switch has no documentation. */
188 static const char undocumented_msg[] = N_("This switch lacks documentation");
190 typedef char *char_p; /* For DEF_VEC_P. */
192 static void handle_param (struct gcc_options *opts,
193 struct gcc_options *opts_set, location_t loc,
194 const char *carg);
195 static void set_debug_level (enum debug_info_type type, int extended,
196 const char *arg, struct gcc_options *opts,
197 struct gcc_options *opts_set,
198 location_t loc);
199 static void set_fast_math_flags (struct gcc_options *opts, int set);
200 static void decode_d_option (const char *arg, struct gcc_options *opts,
201 location_t loc, diagnostic_context *dc);
202 static void set_unsafe_math_optimizations_flags (struct gcc_options *opts,
203 int set);
204 static void enable_warning_as_error (const char *arg, int value,
205 unsigned int lang_mask,
206 const struct cl_option_handlers *handlers,
207 struct gcc_options *opts,
208 struct gcc_options *opts_set,
209 location_t loc,
210 diagnostic_context *dc);
212 /* Handle a back-end option; arguments and return value as for
213 handle_option. */
215 bool
216 target_handle_option (struct gcc_options *opts,
217 struct gcc_options *opts_set,
218 const struct cl_decoded_option *decoded,
219 unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
220 location_t loc,
221 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
222 diagnostic_context *dc)
224 gcc_assert (dc == global_dc);
225 gcc_assert (kind == DK_UNSPECIFIED);
226 return targetm_common.handle_option (opts, opts_set, decoded, loc);
229 /* Add comma-separated strings to a char_p vector. */
231 static void
232 add_comma_separated_to_vector (void **pvec, const char *arg)
234 char *tmp;
235 char *r;
236 char *w;
237 char *token_start;
238 vec<char_p> *v = (vec<char_p> *) *pvec;
240 vec_check_alloc (v, 1);
242 /* We never free this string. */
243 tmp = xstrdup (arg);
245 r = tmp;
246 w = tmp;
247 token_start = tmp;
249 while (*r != '\0')
251 if (*r == ',')
253 *w++ = '\0';
254 ++r;
255 v->safe_push (token_start);
256 token_start = w;
258 if (*r == '\\' && r[1] == ',')
260 *w++ = ',';
261 r += 2;
263 else
264 *w++ = *r++;
266 if (*token_start != '\0')
267 v->safe_push (token_start);
269 *pvec = v;
272 /* Initialize OPTS and OPTS_SET before using them in parsing options. */
274 void
275 init_options_struct (struct gcc_options *opts, struct gcc_options *opts_set)
277 size_t num_params = get_num_compiler_params ();
279 gcc_obstack_init (&opts_obstack);
281 *opts = global_options_init;
283 if (opts_set)
284 memset (opts_set, 0, sizeof (*opts_set));
286 opts->x_param_values = XNEWVEC (int, num_params);
288 if (opts_set)
289 opts_set->x_param_values = XCNEWVEC (int, num_params);
291 init_param_values (opts->x_param_values);
293 /* Initialize whether `char' is signed. */
294 opts->x_flag_signed_char = DEFAULT_SIGNED_CHAR;
295 /* Set this to a special "uninitialized" value. The actual default
296 is set after target options have been processed. */
297 opts->x_flag_short_enums = 2;
299 /* Initialize target_flags before default_options_optimization
300 so the latter can modify it. */
301 opts->x_target_flags = targetm_common.default_target_flags;
303 /* Some targets have ABI-specified unwind tables. */
304 opts->x_flag_unwind_tables = targetm_common.unwind_tables_default;
306 /* Some targets have other target-specific initialization. */
307 targetm_common.option_init_struct (opts);
310 /* If indicated by the optimization level LEVEL (-Os if SIZE is set,
311 -Ofast if FAST is set, -Og if DEBUG is set), apply the option DEFAULT_OPT
312 to OPTS and OPTS_SET, diagnostic context DC, location LOC, with language
313 mask LANG_MASK and option handlers HANDLERS. */
315 static void
316 maybe_default_option (struct gcc_options *opts,
317 struct gcc_options *opts_set,
318 const struct default_options *default_opt,
319 int level, bool size, bool fast, bool debug,
320 unsigned int lang_mask,
321 const struct cl_option_handlers *handlers,
322 location_t loc,
323 diagnostic_context *dc)
325 const struct cl_option *option = &cl_options[default_opt->opt_index];
326 bool enabled;
328 if (size)
329 gcc_assert (level == 2);
330 if (fast)
331 gcc_assert (level == 3);
332 if (debug)
333 gcc_assert (level == 1);
335 switch (default_opt->levels)
337 case OPT_LEVELS_ALL:
338 enabled = true;
339 break;
341 case OPT_LEVELS_0_ONLY:
342 enabled = (level == 0);
343 break;
345 case OPT_LEVELS_1_PLUS:
346 enabled = (level >= 1);
347 break;
349 case OPT_LEVELS_1_PLUS_SPEED_ONLY:
350 enabled = (level >= 1 && !size && !debug);
351 break;
353 case OPT_LEVELS_1_PLUS_NOT_DEBUG:
354 enabled = (level >= 1 && !debug);
355 break;
357 case OPT_LEVELS_2_PLUS:
358 enabled = (level >= 2);
359 break;
361 case OPT_LEVELS_2_PLUS_SPEED_ONLY:
362 enabled = (level >= 2 && !size && !debug);
363 break;
365 case OPT_LEVELS_3_PLUS:
366 enabled = (level >= 3);
367 break;
369 case OPT_LEVELS_3_PLUS_AND_SIZE:
370 enabled = (level >= 3 || size);
371 break;
373 case OPT_LEVELS_SIZE:
374 enabled = size;
375 break;
377 case OPT_LEVELS_FAST:
378 enabled = fast;
379 break;
381 case OPT_LEVELS_NONE:
382 default:
383 gcc_unreachable ();
386 if (enabled)
387 handle_generated_option (opts, opts_set, default_opt->opt_index,
388 default_opt->arg, default_opt->value,
389 lang_mask, DK_UNSPECIFIED, loc,
390 handlers, dc);
391 else if (default_opt->arg == NULL
392 && !option->cl_reject_negative)
393 handle_generated_option (opts, opts_set, default_opt->opt_index,
394 default_opt->arg, !default_opt->value,
395 lang_mask, DK_UNSPECIFIED, loc,
396 handlers, dc);
399 /* As indicated by the optimization level LEVEL (-Os if SIZE is set,
400 -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
401 OPTS and OPTS_SET, diagnostic context DC, location LOC, with
402 language mask LANG_MASK and option handlers HANDLERS. */
404 static void
405 maybe_default_options (struct gcc_options *opts,
406 struct gcc_options *opts_set,
407 const struct default_options *default_opts,
408 int level, bool size, bool fast, bool debug,
409 unsigned int lang_mask,
410 const struct cl_option_handlers *handlers,
411 location_t loc,
412 diagnostic_context *dc)
414 size_t i;
416 for (i = 0; default_opts[i].levels != OPT_LEVELS_NONE; i++)
417 maybe_default_option (opts, opts_set, &default_opts[i],
418 level, size, fast, debug,
419 lang_mask, handlers, loc, dc);
422 /* Table of options enabled by default at different levels. */
424 static const struct default_options default_options_table[] =
426 /* -O1 optimizations. */
427 { OPT_LEVELS_1_PLUS, OPT_fdefer_pop, NULL, 1 },
428 #ifdef DELAY_SLOTS
429 { OPT_LEVELS_1_PLUS, OPT_fdelayed_branch, NULL, 1 },
430 #endif
431 { OPT_LEVELS_1_PLUS, OPT_fguess_branch_probability, NULL, 1 },
432 { OPT_LEVELS_1_PLUS, OPT_fcprop_registers, NULL, 1 },
433 { OPT_LEVELS_1_PLUS, OPT_fforward_propagate, NULL, 1 },
434 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fif_conversion, NULL, 1 },
435 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fif_conversion2, NULL, 1 },
436 { OPT_LEVELS_1_PLUS, OPT_fipa_pure_const, NULL, 1 },
437 { OPT_LEVELS_1_PLUS, OPT_fipa_reference, NULL, 1 },
438 { OPT_LEVELS_1_PLUS, OPT_fipa_profile, NULL, 1 },
439 { OPT_LEVELS_1_PLUS, OPT_fmerge_constants, NULL, 1 },
440 { OPT_LEVELS_1_PLUS, OPT_fshrink_wrap, NULL, 1 },
441 { OPT_LEVELS_1_PLUS, OPT_fsplit_wide_types, NULL, 1 },
442 { OPT_LEVELS_1_PLUS, OPT_ftree_ccp, NULL, 1 },
443 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_bit_ccp, NULL, 1 },
444 { OPT_LEVELS_1_PLUS, OPT_ftree_dce, NULL, 1 },
445 { OPT_LEVELS_1_PLUS, OPT_ftree_dominator_opts, NULL, 1 },
446 { OPT_LEVELS_1_PLUS, OPT_ftree_dse, NULL, 1 },
447 { OPT_LEVELS_1_PLUS, OPT_ftree_ter, NULL, 1 },
448 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_sra, NULL, 1 },
449 { OPT_LEVELS_1_PLUS, OPT_ftree_copyrename, NULL, 1 },
450 { OPT_LEVELS_1_PLUS, OPT_ftree_fre, NULL, 1 },
451 { OPT_LEVELS_1_PLUS, OPT_ftree_copy_prop, NULL, 1 },
452 { OPT_LEVELS_1_PLUS, OPT_ftree_sink, NULL, 1 },
453 { OPT_LEVELS_1_PLUS, OPT_ftree_ch, NULL, 1 },
454 { OPT_LEVELS_1_PLUS, OPT_fcombine_stack_adjustments, NULL, 1 },
455 { OPT_LEVELS_1_PLUS, OPT_fcompare_elim, NULL, 1 },
456 { OPT_LEVELS_1_PLUS, OPT_ftree_slsr, NULL, 1 },
457 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fbranch_count_reg, NULL, 1 },
458 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fmove_loop_invariants, NULL, 1 },
459 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_pta, NULL, 1 },
460 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fssa_phiopt, NULL, 1 },
462 /* -O2 optimizations. */
463 { OPT_LEVELS_2_PLUS, OPT_finline_small_functions, NULL, 1 },
464 { OPT_LEVELS_2_PLUS, OPT_findirect_inlining, NULL, 1 },
465 { OPT_LEVELS_2_PLUS, OPT_fpartial_inlining, NULL, 1 },
466 { OPT_LEVELS_2_PLUS, OPT_fthread_jumps, NULL, 1 },
467 { OPT_LEVELS_2_PLUS, OPT_fcrossjumping, NULL, 1 },
468 { OPT_LEVELS_2_PLUS, OPT_foptimize_sibling_calls, NULL, 1 },
469 { OPT_LEVELS_2_PLUS, OPT_fcse_follow_jumps, NULL, 1 },
470 { OPT_LEVELS_2_PLUS, OPT_fgcse, NULL, 1 },
471 { OPT_LEVELS_2_PLUS, OPT_fexpensive_optimizations, NULL, 1 },
472 { OPT_LEVELS_2_PLUS, OPT_frerun_cse_after_loop, NULL, 1 },
473 { OPT_LEVELS_2_PLUS, OPT_fcaller_saves, NULL, 1 },
474 { OPT_LEVELS_2_PLUS, OPT_fpeephole2, NULL, 1 },
475 #ifdef INSN_SCHEDULING
476 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
477 { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_fschedule_insns, NULL, 1 },
478 { OPT_LEVELS_2_PLUS, OPT_fschedule_insns2, NULL, 1 },
479 #endif
480 { OPT_LEVELS_2_PLUS, OPT_fstrict_aliasing, NULL, 1 },
481 { OPT_LEVELS_2_PLUS, OPT_fstrict_overflow, NULL, 1 },
482 { OPT_LEVELS_2_PLUS, OPT_freorder_blocks, NULL, 1 },
483 { OPT_LEVELS_2_PLUS, OPT_freorder_functions, NULL, 1 },
484 { OPT_LEVELS_2_PLUS, OPT_ftree_vrp, NULL, 1 },
485 { OPT_LEVELS_2_PLUS, OPT_ftree_builtin_call_dce, NULL, 1 },
486 { OPT_LEVELS_2_PLUS, OPT_ftree_pre, NULL, 1 },
487 { OPT_LEVELS_2_PLUS, OPT_ftree_switch_conversion, NULL, 1 },
488 { OPT_LEVELS_2_PLUS, OPT_fipa_cp, NULL, 1 },
489 { OPT_LEVELS_2_PLUS, OPT_fdevirtualize, NULL, 1 },
490 { OPT_LEVELS_2_PLUS, OPT_fdevirtualize_speculatively, NULL, 1 },
491 { OPT_LEVELS_2_PLUS, OPT_fipa_sra, NULL, 1 },
492 { OPT_LEVELS_2_PLUS, OPT_falign_loops, NULL, 1 },
493 { OPT_LEVELS_2_PLUS, OPT_falign_jumps, NULL, 1 },
494 { OPT_LEVELS_2_PLUS, OPT_falign_labels, NULL, 1 },
495 { OPT_LEVELS_2_PLUS, OPT_falign_functions, NULL, 1 },
496 { OPT_LEVELS_2_PLUS, OPT_ftree_tail_merge, NULL, 1 },
497 { OPT_LEVELS_2_PLUS, OPT_fvect_cost_model_, NULL, VECT_COST_MODEL_CHEAP },
498 { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_foptimize_strlen, NULL, 1 },
499 { OPT_LEVELS_2_PLUS, OPT_fhoist_adjacent_loads, NULL, 1 },
500 { OPT_LEVELS_2_PLUS, OPT_fisolate_erroneous_paths_dereference, NULL, 1 },
501 { OPT_LEVELS_2_PLUS, OPT_fuse_caller_save, NULL, 1 },
503 /* -O3 optimizations. */
504 { OPT_LEVELS_3_PLUS, OPT_ftree_loop_distribute_patterns, NULL, 1 },
505 { OPT_LEVELS_3_PLUS, OPT_fpredictive_commoning, NULL, 1 },
506 /* Inlining of functions reducing size is a good idea with -Os
507 regardless of them being declared inline. */
508 { OPT_LEVELS_3_PLUS_AND_SIZE, OPT_finline_functions, NULL, 1 },
509 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_finline_functions_called_once, NULL, 1 },
510 { OPT_LEVELS_3_PLUS, OPT_funswitch_loops, NULL, 1 },
511 { OPT_LEVELS_3_PLUS, OPT_fgcse_after_reload, NULL, 1 },
512 { OPT_LEVELS_3_PLUS, OPT_ftree_loop_vectorize, NULL, 1 },
513 { OPT_LEVELS_3_PLUS, OPT_ftree_slp_vectorize, NULL, 1 },
514 { OPT_LEVELS_3_PLUS, OPT_fvect_cost_model_, NULL, VECT_COST_MODEL_DYNAMIC },
515 { OPT_LEVELS_3_PLUS, OPT_fipa_cp_clone, NULL, 1 },
516 { OPT_LEVELS_3_PLUS, OPT_ftree_partial_pre, NULL, 1 },
518 /* -Ofast adds optimizations to -O3. */
519 { OPT_LEVELS_FAST, OPT_ffast_math, NULL, 1 },
521 { OPT_LEVELS_NONE, 0, NULL, 0 }
524 /* Default the options in OPTS and OPTS_SET based on the optimization
525 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
526 void
527 default_options_optimization (struct gcc_options *opts,
528 struct gcc_options *opts_set,
529 struct cl_decoded_option *decoded_options,
530 unsigned int decoded_options_count,
531 location_t loc,
532 unsigned int lang_mask,
533 const struct cl_option_handlers *handlers,
534 diagnostic_context *dc)
536 unsigned int i;
537 int opt2;
539 /* Scan to see what optimization level has been specified. That will
540 determine the default value of many flags. */
541 for (i = 1; i < decoded_options_count; i++)
543 struct cl_decoded_option *opt = &decoded_options[i];
544 switch (opt->opt_index)
546 case OPT_O:
547 if (*opt->arg == '\0')
549 opts->x_optimize = 1;
550 opts->x_optimize_size = 0;
551 opts->x_optimize_fast = 0;
552 opts->x_optimize_debug = 0;
554 else
556 const int optimize_val = integral_argument (opt->arg);
557 if (optimize_val == -1)
558 error_at (loc, "argument to %<-O%> should be a non-negative "
559 "integer, %<g%>, %<s%> or %<fast%>");
560 else
562 opts->x_optimize = optimize_val;
563 if ((unsigned int) opts->x_optimize > 255)
564 opts->x_optimize = 255;
565 opts->x_optimize_size = 0;
566 opts->x_optimize_fast = 0;
567 opts->x_optimize_debug = 0;
570 break;
572 case OPT_Os:
573 opts->x_optimize_size = 1;
575 /* Optimizing for size forces optimize to be 2. */
576 opts->x_optimize = 2;
577 opts->x_optimize_fast = 0;
578 opts->x_optimize_debug = 0;
579 break;
581 case OPT_Ofast:
582 /* -Ofast only adds flags to -O3. */
583 opts->x_optimize_size = 0;
584 opts->x_optimize = 3;
585 opts->x_optimize_fast = 1;
586 opts->x_optimize_debug = 0;
587 break;
589 case OPT_Og:
590 /* -Og selects optimization level 1. */
591 opts->x_optimize_size = 0;
592 opts->x_optimize = 1;
593 opts->x_optimize_fast = 0;
594 opts->x_optimize_debug = 1;
595 break;
597 default:
598 /* Ignore other options in this prescan. */
599 break;
603 maybe_default_options (opts, opts_set, default_options_table,
604 opts->x_optimize, opts->x_optimize_size,
605 opts->x_optimize_fast, opts->x_optimize_debug,
606 lang_mask, handlers, loc, dc);
608 /* -O2 param settings. */
609 opt2 = (opts->x_optimize >= 2);
611 /* Track fields in field-sensitive alias analysis. */
612 maybe_set_param_value
613 (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE,
614 opt2 ? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE),
615 opts->x_param_values, opts_set->x_param_values);
617 /* For -O1 only do loop invariant motion for very small loops. */
618 maybe_set_param_value
619 (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP,
620 opt2 ? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP) : 1000,
621 opts->x_param_values, opts_set->x_param_values);
623 /* At -Ofast, allow store motion to introduce potential race conditions. */
624 maybe_set_param_value
625 (PARAM_ALLOW_STORE_DATA_RACES,
626 opts->x_optimize_fast ? 1
627 : default_param_value (PARAM_ALLOW_STORE_DATA_RACES),
628 opts->x_param_values, opts_set->x_param_values);
630 if (opts->x_optimize_size)
631 /* We want to crossjump as much as possible. */
632 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS, 1,
633 opts->x_param_values, opts_set->x_param_values);
634 else
635 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS,
636 default_param_value (PARAM_MIN_CROSSJUMP_INSNS),
637 opts->x_param_values, opts_set->x_param_values);
639 /* Restrict the amount of work combine does at -Og while retaining
640 most of its useful transforms. */
641 if (opts->x_optimize_debug)
642 maybe_set_param_value (PARAM_MAX_COMBINE_INSNS, 2,
643 opts->x_param_values, opts_set->x_param_values);
645 /* Allow default optimizations to be specified on a per-machine basis. */
646 maybe_default_options (opts, opts_set,
647 targetm_common.option_optimization_table,
648 opts->x_optimize, opts->x_optimize_size,
649 opts->x_optimize_fast, opts->x_optimize_debug,
650 lang_mask, handlers, loc, dc);
653 /* After all options at LOC have been read into OPTS and OPTS_SET,
654 finalize settings of those options and diagnose incompatible
655 combinations. */
656 void
657 finish_options (struct gcc_options *opts, struct gcc_options *opts_set,
658 location_t loc)
660 enum unwind_info_type ui_except;
662 if (opts->x_dump_base_name
663 && ! IS_ABSOLUTE_PATH (opts->x_dump_base_name)
664 && ! opts->x_dump_base_name_prefixed)
666 /* First try to make OPTS->X_DUMP_BASE_NAME relative to the
667 OPTS->X_DUMP_DIR_NAME directory. Then try to make
668 OPTS->X_DUMP_BASE_NAME relative to the OPTS->X_AUX_BASE_NAME
669 directory, typically the directory to contain the object
670 file. */
671 if (opts->x_dump_dir_name)
672 opts->x_dump_base_name = opts_concat (opts->x_dump_dir_name,
673 opts->x_dump_base_name, NULL);
674 else if (opts->x_aux_base_name
675 && strcmp (opts->x_aux_base_name, HOST_BIT_BUCKET) != 0)
677 const char *aux_base;
679 base_of_path (opts->x_aux_base_name, &aux_base);
680 if (opts->x_aux_base_name != aux_base)
682 int dir_len = aux_base - opts->x_aux_base_name;
683 char *new_dump_base_name
684 = XOBNEWVEC (&opts_obstack, char,
685 strlen (opts->x_dump_base_name) + dir_len + 1);
687 /* Copy directory component from OPTS->X_AUX_BASE_NAME. */
688 memcpy (new_dump_base_name, opts->x_aux_base_name, dir_len);
689 /* Append existing OPTS->X_DUMP_BASE_NAME. */
690 strcpy (new_dump_base_name + dir_len, opts->x_dump_base_name);
691 opts->x_dump_base_name = new_dump_base_name;
694 opts->x_dump_base_name_prefixed = true;
697 /* Handle related options for unit-at-a-time, toplevel-reorder, and
698 section-anchors. */
699 if (!opts->x_flag_unit_at_a_time)
701 if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
702 error_at (loc, "section anchors must be disabled when unit-at-a-time "
703 "is disabled");
704 opts->x_flag_section_anchors = 0;
705 if (opts->x_flag_toplevel_reorder == 1)
706 error_at (loc, "toplevel reorder must be disabled when unit-at-a-time "
707 "is disabled");
708 opts->x_flag_toplevel_reorder = 0;
711 if (opts->x_flag_tm && opts->x_flag_non_call_exceptions)
712 sorry ("transactional memory is not supported with non-call exceptions");
714 /* Unless the user has asked for section anchors, we disable toplevel
715 reordering at -O0 to disable transformations that might be surprising
716 to end users and to get -fno-toplevel-reorder tested. */
717 if (!opts->x_optimize
718 && opts->x_flag_toplevel_reorder == 2
719 && !(opts->x_flag_section_anchors && opts_set->x_flag_section_anchors))
721 opts->x_flag_toplevel_reorder = 0;
722 opts->x_flag_section_anchors = 0;
724 if (!opts->x_flag_toplevel_reorder)
726 if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
727 error_at (loc, "section anchors must be disabled when toplevel reorder"
728 " is disabled");
729 opts->x_flag_section_anchors = 0;
732 if (!opts->x_flag_opts_finished)
734 if (opts->x_flag_pie)
735 opts->x_flag_pic = opts->x_flag_pie;
736 if (opts->x_flag_pic && !opts->x_flag_pie)
737 opts->x_flag_shlib = 1;
738 opts->x_flag_opts_finished = true;
741 if (opts->x_optimize == 0)
743 /* Inlining does not work if not optimizing,
744 so force it not to be done. */
745 opts->x_warn_inline = 0;
746 opts->x_flag_no_inline = 1;
749 /* The optimization to partition hot and cold basic blocks into separate
750 sections of the .o and executable files does not work (currently)
751 with exception handling. This is because there is no support for
752 generating unwind info. If opts->x_flag_exceptions is turned on
753 we need to turn off the partitioning optimization. */
755 ui_except = targetm_common.except_unwind_info (opts);
757 if (opts->x_flag_exceptions
758 && opts->x_flag_reorder_blocks_and_partition
759 && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))
761 if (opts_set->x_flag_reorder_blocks_and_partition)
762 inform (loc,
763 "-freorder-blocks-and-partition does not work "
764 "with exceptions on this architecture");
765 opts->x_flag_reorder_blocks_and_partition = 0;
766 opts->x_flag_reorder_blocks = 1;
769 /* If user requested unwind info, then turn off the partitioning
770 optimization. */
772 if (opts->x_flag_unwind_tables
773 && !targetm_common.unwind_tables_default
774 && opts->x_flag_reorder_blocks_and_partition
775 && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))
777 if (opts_set->x_flag_reorder_blocks_and_partition)
778 inform (loc,
779 "-freorder-blocks-and-partition does not support "
780 "unwind info on this architecture");
781 opts->x_flag_reorder_blocks_and_partition = 0;
782 opts->x_flag_reorder_blocks = 1;
785 /* If the target requested unwind info, then turn off the partitioning
786 optimization with a different message. Likewise, if the target does not
787 support named sections. */
789 if (opts->x_flag_reorder_blocks_and_partition
790 && (!targetm_common.have_named_sections
791 || (opts->x_flag_unwind_tables
792 && targetm_common.unwind_tables_default
793 && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))))
795 if (opts_set->x_flag_reorder_blocks_and_partition)
796 inform (loc,
797 "-freorder-blocks-and-partition does not work "
798 "on this architecture");
799 opts->x_flag_reorder_blocks_and_partition = 0;
800 opts->x_flag_reorder_blocks = 1;
803 if (opts->x_flag_reorder_blocks_and_partition
804 && !opts_set->x_flag_reorder_functions)
805 opts->x_flag_reorder_functions = 1;
807 /* Pipelining of outer loops is only possible when general pipelining
808 capabilities are requested. */
809 if (!opts->x_flag_sel_sched_pipelining)
810 opts->x_flag_sel_sched_pipelining_outer_loops = 0;
812 if (opts->x_flag_conserve_stack)
814 maybe_set_param_value (PARAM_LARGE_STACK_FRAME, 100,
815 opts->x_param_values, opts_set->x_param_values);
816 maybe_set_param_value (PARAM_STACK_FRAME_GROWTH, 40,
817 opts->x_param_values, opts_set->x_param_values);
820 if (opts->x_flag_lto)
822 #ifdef ENABLE_LTO
823 opts->x_flag_generate_lto = 1;
825 /* When generating IL, do not operate in whole-program mode.
826 Otherwise, symbols will be privatized too early, causing link
827 errors later. */
828 opts->x_flag_whole_program = 0;
829 #else
830 error_at (loc, "LTO support has not been enabled in this configuration");
831 #endif
832 if (!opts->x_flag_fat_lto_objects
833 && (!HAVE_LTO_PLUGIN
834 || (opts_set->x_flag_use_linker_plugin
835 && !opts->x_flag_use_linker_plugin)))
837 if (opts_set->x_flag_fat_lto_objects)
838 error_at (loc, "-fno-fat-lto-objects are supported only with linker plugin");
839 opts->x_flag_fat_lto_objects = 1;
843 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
844 default value if they choose based on other options. */
845 if (opts->x_flag_split_stack == -1)
846 opts->x_flag_split_stack = 0;
847 else if (opts->x_flag_split_stack)
849 if (!targetm_common.supports_split_stack (true, opts))
851 error_at (loc, "%<-fsplit-stack%> is not supported by "
852 "this compiler configuration");
853 opts->x_flag_split_stack = 0;
857 /* Tune vectorization related parametees according to cost model. */
858 if (opts->x_flag_vect_cost_model == VECT_COST_MODEL_CHEAP)
860 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS,
861 6, opts->x_param_values, opts_set->x_param_values);
862 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS,
863 0, opts->x_param_values, opts_set->x_param_values);
864 maybe_set_param_value (PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT,
865 0, opts->x_param_values, opts_set->x_param_values);
868 /* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
869 is disabled. */
870 if ((!opts->x_flag_tree_loop_vectorize && !opts->x_flag_tree_slp_vectorize)
871 || !opts->x_flag_tree_loop_if_convert)
872 maybe_set_param_value (PARAM_MAX_STORES_TO_SINK, 0,
873 opts->x_param_values, opts_set->x_param_values);
875 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
876 if (opts->x_dwarf_split_debug_info)
877 opts->x_debug_generate_pub_sections = 2;
879 /* Userspace and kernel ASan conflict with each other and with TSan. */
881 if ((flag_sanitize & SANITIZE_USER_ADDRESS)
882 && (flag_sanitize & SANITIZE_KERNEL_ADDRESS))
883 error_at (loc,
884 "-fsanitize=address is incompatible with "
885 "-fsanitize=kernel-address");
887 if ((flag_sanitize & SANITIZE_ADDRESS)
888 && (flag_sanitize & SANITIZE_THREAD))
889 error_at (loc,
890 "-fsanitize=address and -fsanitize=kernel-address "
891 "are incompatible with -fsanitize=thread");
894 #define LEFT_COLUMN 27
896 /* Output ITEM, of length ITEM_WIDTH, in the left column,
897 followed by word-wrapped HELP in a second column. */
898 static void
899 wrap_help (const char *help,
900 const char *item,
901 unsigned int item_width,
902 unsigned int columns)
904 unsigned int col_width = LEFT_COLUMN;
905 unsigned int remaining, room, len;
907 remaining = strlen (help);
911 room = columns - 3 - MAX (col_width, item_width);
912 if (room > columns)
913 room = 0;
914 len = remaining;
916 if (room < len)
918 unsigned int i;
920 for (i = 0; help[i]; i++)
922 if (i >= room && len != remaining)
923 break;
924 if (help[i] == ' ')
925 len = i;
926 else if ((help[i] == '-' || help[i] == '/')
927 && help[i + 1] != ' '
928 && i > 0 && ISALPHA (help[i - 1]))
929 len = i + 1;
933 printf (" %-*.*s %.*s\n", col_width, item_width, item, len, help);
934 item_width = 0;
935 while (help[len] == ' ')
936 len++;
937 help += len;
938 remaining -= len;
940 while (remaining);
943 /* Print help for a specific front-end, etc. */
944 static void
945 print_filtered_help (unsigned int include_flags,
946 unsigned int exclude_flags,
947 unsigned int any_flags,
948 unsigned int columns,
949 struct gcc_options *opts,
950 unsigned int lang_mask)
952 unsigned int i;
953 const char *help;
954 bool found = false;
955 bool displayed = false;
957 if (include_flags == CL_PARAMS)
959 for (i = 0; i < LAST_PARAM; i++)
961 const char *param = compiler_params[i].option;
963 help = compiler_params[i].help;
964 if (help == NULL || *help == '\0')
966 if (exclude_flags & CL_UNDOCUMENTED)
967 continue;
968 help = undocumented_msg;
971 /* Get the translation. */
972 help = _(help);
974 wrap_help (help, param, strlen (param), columns);
976 putchar ('\n');
977 return;
980 if (!opts->x_help_printed)
981 opts->x_help_printed = XCNEWVAR (char, cl_options_count);
983 if (!opts->x_help_enum_printed)
984 opts->x_help_enum_printed = XCNEWVAR (char, cl_enums_count);
986 for (i = 0; i < cl_options_count; i++)
988 char new_help[128];
989 const struct cl_option *option = cl_options + i;
990 unsigned int len;
991 const char *opt;
992 const char *tab;
994 if (include_flags == 0
995 || ((option->flags & include_flags) != include_flags))
997 if ((option->flags & any_flags) == 0)
998 continue;
1001 /* Skip unwanted switches. */
1002 if ((option->flags & exclude_flags) != 0)
1003 continue;
1005 /* The driver currently prints its own help text. */
1006 if ((option->flags & CL_DRIVER) != 0
1007 && (option->flags & (((1U << cl_lang_count) - 1)
1008 | CL_COMMON | CL_TARGET)) == 0)
1009 continue;
1011 found = true;
1012 /* Skip switches that have already been printed. */
1013 if (opts->x_help_printed[i])
1014 continue;
1016 opts->x_help_printed[i] = true;
1018 help = option->help;
1019 if (help == NULL)
1021 if (exclude_flags & CL_UNDOCUMENTED)
1022 continue;
1023 help = undocumented_msg;
1026 /* Get the translation. */
1027 help = _(help);
1029 /* Find the gap between the name of the
1030 option and its descriptive text. */
1031 tab = strchr (help, '\t');
1032 if (tab)
1034 len = tab - help;
1035 opt = help;
1036 help = tab + 1;
1038 else
1040 opt = option->opt_text;
1041 len = strlen (opt);
1044 /* With the -Q option enabled we change the descriptive text associated
1045 with an option to be an indication of its current setting. */
1046 if (!opts->x_quiet_flag)
1048 void *flag_var = option_flag_var (i, opts);
1050 if (len < (LEFT_COLUMN + 2))
1051 strcpy (new_help, "\t\t");
1052 else
1053 strcpy (new_help, "\t");
1055 if (flag_var != NULL
1056 && option->var_type != CLVC_DEFER)
1058 if (option->flags & CL_JOINED)
1060 if (option->var_type == CLVC_STRING)
1062 if (* (const char **) flag_var != NULL)
1063 snprintf (new_help + strlen (new_help),
1064 sizeof (new_help) - strlen (new_help),
1065 * (const char **) flag_var);
1067 else if (option->var_type == CLVC_ENUM)
1069 const struct cl_enum *e = &cl_enums[option->var_enum];
1070 int value;
1071 const char *arg = NULL;
1073 value = e->get (flag_var);
1074 enum_value_to_arg (e->values, &arg, value, lang_mask);
1075 if (arg == NULL)
1076 arg = _("[default]");
1077 snprintf (new_help + strlen (new_help),
1078 sizeof (new_help) - strlen (new_help),
1079 arg);
1081 else
1082 sprintf (new_help + strlen (new_help),
1083 "%#x", * (int *) flag_var);
1085 else
1086 strcat (new_help, option_enabled (i, opts)
1087 ? _("[enabled]") : _("[disabled]"));
1090 help = new_help;
1093 wrap_help (help, opt, len, columns);
1094 displayed = true;
1096 if (option->var_type == CLVC_ENUM
1097 && opts->x_help_enum_printed[option->var_enum] != 2)
1098 opts->x_help_enum_printed[option->var_enum] = 1;
1101 if (! found)
1103 unsigned int langs = include_flags & CL_LANG_ALL;
1105 if (langs == 0)
1106 printf (_(" No options with the desired characteristics were found\n"));
1107 else
1109 unsigned int i;
1111 /* PR 31349: Tell the user how to see all of the
1112 options supported by a specific front end. */
1113 for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1114 if ((1U << i) & langs)
1115 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end\n"),
1116 lang_names[i], lang_names[i]);
1120 else if (! displayed)
1121 printf (_(" All options with the desired characteristics have already been displayed\n"));
1123 putchar ('\n');
1125 /* Print details of enumerated option arguments, if those
1126 enumerations have help text headings provided. If no help text
1127 is provided, presume that the possible values are listed in the
1128 help text for the relevant options. */
1129 for (i = 0; i < cl_enums_count; i++)
1131 unsigned int j, pos;
1133 if (opts->x_help_enum_printed[i] != 1)
1134 continue;
1135 if (cl_enums[i].help == NULL)
1136 continue;
1137 printf (" %s\n ", _(cl_enums[i].help));
1138 pos = 4;
1139 for (j = 0; cl_enums[i].values[j].arg != NULL; j++)
1141 unsigned int len = strlen (cl_enums[i].values[j].arg);
1143 if (pos > 4 && pos + 1 + len <= columns)
1145 printf (" %s", cl_enums[i].values[j].arg);
1146 pos += 1 + len;
1148 else
1150 if (pos > 4)
1152 printf ("\n ");
1153 pos = 4;
1155 printf ("%s", cl_enums[i].values[j].arg);
1156 pos += len;
1159 printf ("\n\n");
1160 opts->x_help_enum_printed[i] = 2;
1164 /* Display help for a specified type of option.
1165 The options must have ALL of the INCLUDE_FLAGS set
1166 ANY of the flags in the ANY_FLAGS set
1167 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1168 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1169 static void
1170 print_specific_help (unsigned int include_flags,
1171 unsigned int exclude_flags,
1172 unsigned int any_flags,
1173 struct gcc_options *opts,
1174 unsigned int lang_mask)
1176 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1177 const char * description = NULL;
1178 const char * descrip_extra = "";
1179 size_t i;
1180 unsigned int flag;
1182 /* Sanity check: Make sure that we do not have more
1183 languages than we have bits available to enumerate them. */
1184 gcc_assert ((1U << cl_lang_count) <= CL_MIN_OPTION_CLASS);
1186 /* If we have not done so already, obtain
1187 the desired maximum width of the output. */
1188 if (opts->x_help_columns == 0)
1190 const char *p;
1192 p = getenv ("COLUMNS");
1193 if (p != NULL)
1195 int value = atoi (p);
1197 if (value > 0)
1198 opts->x_help_columns = value;
1201 if (opts->x_help_columns == 0)
1202 /* Use a reasonable default. */
1203 opts->x_help_columns = 80;
1206 /* Decide upon the title for the options that we are going to display. */
1207 for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1209 switch (flag & include_flags)
1211 case 0:
1212 case CL_DRIVER:
1213 break;
1215 case CL_TARGET:
1216 description = _("The following options are target specific");
1217 break;
1218 case CL_WARNING:
1219 description = _("The following options control compiler warning messages");
1220 break;
1221 case CL_OPTIMIZATION:
1222 description = _("The following options control optimizations");
1223 break;
1224 case CL_COMMON:
1225 description = _("The following options are language-independent");
1226 break;
1227 case CL_PARAMS:
1228 description = _("The --param option recognizes the following as parameters");
1229 break;
1230 default:
1231 if (i >= cl_lang_count)
1232 break;
1233 if (exclude_flags & all_langs_mask)
1234 description = _("The following options are specific to just the language ");
1235 else
1236 description = _("The following options are supported by the language ");
1237 descrip_extra = lang_names [i];
1238 break;
1242 if (description == NULL)
1244 if (any_flags == 0)
1246 if (include_flags & CL_UNDOCUMENTED)
1247 description = _("The following options are not documented");
1248 else if (include_flags & CL_SEPARATE)
1249 description = _("The following options take separate arguments");
1250 else if (include_flags & CL_JOINED)
1251 description = _("The following options take joined arguments");
1252 else
1254 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1255 include_flags);
1256 return;
1259 else
1261 if (any_flags & all_langs_mask)
1262 description = _("The following options are language-related");
1263 else
1264 description = _("The following options are language-independent");
1268 printf ("%s%s:\n", description, descrip_extra);
1269 print_filtered_help (include_flags, exclude_flags, any_flags,
1270 opts->x_help_columns, opts, lang_mask);
1273 /* Handle target- and language-independent options. Return zero to
1274 generate an "unknown option" message. Only options that need
1275 extra handling need to be listed here; if you simply want
1276 DECODED->value assigned to a variable, it happens automatically. */
1278 bool
1279 common_handle_option (struct gcc_options *opts,
1280 struct gcc_options *opts_set,
1281 const struct cl_decoded_option *decoded,
1282 unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
1283 location_t loc,
1284 const struct cl_option_handlers *handlers,
1285 diagnostic_context *dc)
1287 size_t scode = decoded->opt_index;
1288 const char *arg = decoded->arg;
1289 int value = decoded->value;
1290 enum opt_code code = (enum opt_code) scode;
1292 gcc_assert (decoded->canonical_option_num_elements <= 2);
1294 switch (code)
1296 case OPT__param:
1297 handle_param (opts, opts_set, loc, arg);
1298 break;
1300 case OPT__help:
1302 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1303 unsigned int undoc_mask;
1304 unsigned int i;
1306 if (lang_mask == CL_DRIVER)
1307 break;;
1309 undoc_mask = ((opts->x_verbose_flag | opts->x_extra_warnings)
1311 : CL_UNDOCUMENTED);
1312 /* First display any single language specific options. */
1313 for (i = 0; i < cl_lang_count; i++)
1314 print_specific_help
1315 (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0, opts,
1316 lang_mask);
1317 /* Next display any multi language specific options. */
1318 print_specific_help (0, undoc_mask, all_langs_mask, opts, lang_mask);
1319 /* Then display any remaining, non-language options. */
1320 for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1321 if (i != CL_DRIVER)
1322 print_specific_help (i, undoc_mask, 0, opts, lang_mask);
1323 opts->x_exit_after_options = true;
1324 break;
1327 case OPT__target_help:
1328 if (lang_mask == CL_DRIVER)
1329 break;
1331 print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0, opts, lang_mask);
1332 opts->x_exit_after_options = true;
1333 break;
1335 case OPT__help_:
1337 const char * a = arg;
1338 unsigned int include_flags = 0;
1339 /* Note - by default we include undocumented options when listing
1340 specific classes. If you only want to see documented options
1341 then add ",^undocumented" to the --help= option. E.g.:
1343 --help=target,^undocumented */
1344 unsigned int exclude_flags = 0;
1346 if (lang_mask == CL_DRIVER)
1347 break;
1349 /* Walk along the argument string, parsing each word in turn.
1350 The format is:
1351 arg = [^]{word}[,{arg}]
1352 word = {optimizers|target|warnings|undocumented|
1353 params|common|<language>} */
1354 while (* a != 0)
1356 static const struct
1358 const char * string;
1359 unsigned int flag;
1361 specifics[] =
1363 { "optimizers", CL_OPTIMIZATION },
1364 { "target", CL_TARGET },
1365 { "warnings", CL_WARNING },
1366 { "undocumented", CL_UNDOCUMENTED },
1367 { "params", CL_PARAMS },
1368 { "joined", CL_JOINED },
1369 { "separate", CL_SEPARATE },
1370 { "common", CL_COMMON },
1371 { NULL, 0 }
1373 unsigned int * pflags;
1374 const char * comma;
1375 unsigned int lang_flag, specific_flag;
1376 unsigned int len;
1377 unsigned int i;
1379 if (* a == '^')
1381 ++ a;
1382 pflags = & exclude_flags;
1384 else
1385 pflags = & include_flags;
1387 comma = strchr (a, ',');
1388 if (comma == NULL)
1389 len = strlen (a);
1390 else
1391 len = comma - a;
1392 if (len == 0)
1394 a = comma + 1;
1395 continue;
1398 /* Check to see if the string matches an option class name. */
1399 for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1400 if (strncasecmp (a, specifics[i].string, len) == 0)
1402 specific_flag = specifics[i].flag;
1403 break;
1406 /* Check to see if the string matches a language name.
1407 Note - we rely upon the alpha-sorted nature of the entries in
1408 the lang_names array, specifically that shorter names appear
1409 before their longer variants. (i.e. C before C++). That way
1410 when we are attempting to match --help=c for example we will
1411 match with C first and not C++. */
1412 for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1413 if (strncasecmp (a, lang_names[i], len) == 0)
1415 lang_flag = 1U << i;
1416 break;
1419 if (specific_flag != 0)
1421 if (lang_flag == 0)
1422 * pflags |= specific_flag;
1423 else
1425 /* The option's argument matches both the start of a
1426 language name and the start of an option class name.
1427 We have a special case for when the user has
1428 specified "--help=c", but otherwise we have to issue
1429 a warning. */
1430 if (strncasecmp (a, "c", len) == 0)
1431 * pflags |= lang_flag;
1432 else
1433 warning_at (loc, 0,
1434 "--help argument %q.*s is ambiguous, "
1435 "please be more specific",
1436 len, a);
1439 else if (lang_flag != 0)
1440 * pflags |= lang_flag;
1441 else
1442 warning_at (loc, 0,
1443 "unrecognized argument to --help= option: %q.*s",
1444 len, a);
1446 if (comma == NULL)
1447 break;
1448 a = comma + 1;
1451 if (include_flags)
1452 print_specific_help (include_flags, exclude_flags, 0, opts,
1453 lang_mask);
1454 opts->x_exit_after_options = true;
1455 break;
1458 case OPT__version:
1459 if (lang_mask == CL_DRIVER)
1460 break;
1462 opts->x_exit_after_options = true;
1463 break;
1465 case OPT_fsanitize_:
1467 const char *p = arg;
1468 while (*p != 0)
1470 static const struct
1472 const char *const name;
1473 unsigned int flag;
1474 size_t len;
1475 } spec[] =
1477 { "address", SANITIZE_ADDRESS | SANITIZE_USER_ADDRESS,
1478 sizeof "address" - 1 },
1479 { "kernel-address", SANITIZE_ADDRESS | SANITIZE_KERNEL_ADDRESS,
1480 sizeof "kernel-address" - 1 },
1481 { "thread", SANITIZE_THREAD, sizeof "thread" - 1 },
1482 { "leak", SANITIZE_LEAK, sizeof "leak" - 1 },
1483 { "shift", SANITIZE_SHIFT, sizeof "shift" - 1 },
1484 { "integer-divide-by-zero", SANITIZE_DIVIDE,
1485 sizeof "integer-divide-by-zero" - 1 },
1486 { "undefined", SANITIZE_UNDEFINED, sizeof "undefined" - 1 },
1487 { "unreachable", SANITIZE_UNREACHABLE,
1488 sizeof "unreachable" - 1 },
1489 { "vla-bound", SANITIZE_VLA, sizeof "vla-bound" - 1 },
1490 { "return", SANITIZE_RETURN, sizeof "return" - 1 },
1491 { "null", SANITIZE_NULL, sizeof "null" - 1 },
1492 { "signed-integer-overflow", SANITIZE_SI_OVERFLOW,
1493 sizeof "signed-integer-overflow" -1 },
1494 { "bool", SANITIZE_BOOL, sizeof "bool" - 1 },
1495 { "enum", SANITIZE_ENUM, sizeof "enum" - 1 },
1496 { "float-divide-by-zero", SANITIZE_FLOAT_DIVIDE,
1497 sizeof "float-divide-by-zero" - 1 },
1498 { "float-cast-overflow", SANITIZE_FLOAT_CAST,
1499 sizeof "float-cast-overflow" - 1 },
1500 { "bounds", SANITIZE_BOUNDS, sizeof "bounds" - 1 },
1501 { "alignment", SANITIZE_ALIGNMENT, sizeof "alignment" - 1 },
1502 { "nonnull-attribute", SANITIZE_NONNULL_ATTRIBUTE,
1503 sizeof "nonnull-attribute" - 1 },
1504 { "returns-nonnull-attribute",
1505 SANITIZE_RETURNS_NONNULL_ATTRIBUTE,
1506 sizeof "returns-nonnull-attribute" - 1 },
1507 { NULL, 0, 0 }
1509 const char *comma;
1510 size_t len, i;
1511 bool found = false;
1513 comma = strchr (p, ',');
1514 if (comma == NULL)
1515 len = strlen (p);
1516 else
1517 len = comma - p;
1518 if (len == 0)
1520 p = comma + 1;
1521 continue;
1524 /* Check to see if the string matches an option class name. */
1525 for (i = 0; spec[i].name != NULL; ++i)
1526 if (len == spec[i].len
1527 && memcmp (p, spec[i].name, len) == 0)
1529 /* Handle both -fsanitize and -fno-sanitize cases. */
1530 if (value)
1531 flag_sanitize |= spec[i].flag;
1532 else
1533 flag_sanitize &= ~spec[i].flag;
1534 found = true;
1535 break;
1538 if (! found)
1539 error_at (loc,
1540 "unrecognized argument to -fsanitize= option: %q.*s",
1541 (int) len, p);
1543 if (comma == NULL)
1544 break;
1545 p = comma + 1;
1548 /* When instrumenting the pointers, we don't want to remove
1549 the null pointer checks. */
1550 if (flag_sanitize & (SANITIZE_NULL | SANITIZE_NONNULL_ATTRIBUTE
1551 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE))
1552 opts->x_flag_delete_null_pointer_checks = 0;
1554 /* Kernel ASan implies normal ASan but does not yet support
1555 all features. */
1556 if (flag_sanitize & SANITIZE_KERNEL_ADDRESS)
1558 maybe_set_param_value (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD, 0,
1559 opts->x_param_values,
1560 opts_set->x_param_values);
1561 maybe_set_param_value (PARAM_ASAN_GLOBALS, 0,
1562 opts->x_param_values,
1563 opts_set->x_param_values);
1564 maybe_set_param_value (PARAM_ASAN_STACK, 0,
1565 opts->x_param_values,
1566 opts_set->x_param_values);
1567 maybe_set_param_value (PARAM_ASAN_USE_AFTER_RETURN, 0,
1568 opts->x_param_values,
1569 opts_set->x_param_values);
1572 break;
1575 case OPT_O:
1576 case OPT_Os:
1577 case OPT_Ofast:
1578 case OPT_Og:
1579 /* Currently handled in a prescan. */
1580 break;
1582 case OPT_Werror:
1583 dc->warning_as_error_requested = value;
1584 break;
1586 case OPT_Werror_:
1587 if (lang_mask == CL_DRIVER)
1588 break;
1590 enable_warning_as_error (arg, value, lang_mask, handlers,
1591 opts, opts_set, loc, dc);
1592 break;
1594 case OPT_Wlarger_than_:
1595 opts->x_larger_than_size = value;
1596 opts->x_warn_larger_than = value != -1;
1597 break;
1599 case OPT_Wfatal_errors:
1600 dc->fatal_errors = value;
1601 break;
1603 case OPT_Wframe_larger_than_:
1604 opts->x_frame_larger_than_size = value;
1605 opts->x_warn_frame_larger_than = value != -1;
1606 break;
1608 case OPT_Wstack_usage_:
1609 opts->x_warn_stack_usage = value;
1610 opts->x_flag_stack_usage_info = value != -1;
1611 break;
1613 case OPT_Wstrict_aliasing:
1614 set_Wstrict_aliasing (opts, value);
1615 break;
1617 case OPT_Wstrict_overflow:
1618 opts->x_warn_strict_overflow = (value
1619 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1620 : 0);
1621 break;
1623 case OPT_Wsystem_headers:
1624 dc->dc_warn_system_headers = value;
1625 break;
1627 case OPT_aux_info:
1628 opts->x_flag_gen_aux_info = 1;
1629 break;
1631 case OPT_auxbase_strip:
1633 char *tmp = xstrdup (arg);
1634 strip_off_ending (tmp, strlen (tmp));
1635 if (tmp[0])
1636 opts->x_aux_base_name = tmp;
1637 else
1638 free (tmp);
1640 break;
1642 case OPT_d:
1643 decode_d_option (arg, opts, loc, dc);
1644 break;
1646 case OPT_fcall_used_:
1647 case OPT_fcall_saved_:
1648 /* Deferred. */
1649 break;
1651 case OPT_fdbg_cnt_:
1652 case OPT_fdbg_cnt_list:
1653 /* Deferred. */
1654 break;
1656 case OPT_fdebug_prefix_map_:
1657 /* Deferred. */
1658 break;
1660 case OPT_fdiagnostics_show_location_:
1661 diagnostic_prefixing_rule (dc) = (diagnostic_prefixing_rule_t) value;
1662 break;
1664 case OPT_fdiagnostics_show_caret:
1665 dc->show_caret = value;
1666 break;
1668 case OPT_fdiagnostics_color_:
1669 pp_show_color (dc->printer)
1670 = colorize_init ((diagnostic_color_rule_t) value);
1671 break;
1673 case OPT_fdiagnostics_show_option:
1674 dc->show_option_requested = value;
1675 break;
1677 case OPT_fdump_:
1678 /* Deferred. */
1679 break;
1681 case OPT_ffast_math:
1682 set_fast_math_flags (opts, value);
1683 break;
1685 case OPT_funsafe_math_optimizations:
1686 set_unsafe_math_optimizations_flags (opts, value);
1687 break;
1689 case OPT_ffixed_:
1690 /* Deferred. */
1691 break;
1693 case OPT_finline_limit_:
1694 set_param_value ("max-inline-insns-single", value / 2,
1695 opts->x_param_values, opts_set->x_param_values);
1696 set_param_value ("max-inline-insns-auto", value / 2,
1697 opts->x_param_values, opts_set->x_param_values);
1698 break;
1700 case OPT_finstrument_functions_exclude_function_list_:
1701 add_comma_separated_to_vector
1702 (&opts->x_flag_instrument_functions_exclude_functions, arg);
1703 break;
1705 case OPT_finstrument_functions_exclude_file_list_:
1706 add_comma_separated_to_vector
1707 (&opts->x_flag_instrument_functions_exclude_files, arg);
1708 break;
1710 case OPT_fmessage_length_:
1711 pp_set_line_maximum_length (dc->printer, value);
1712 diagnostic_set_caret_max_width (dc, value);
1713 break;
1715 case OPT_fopt_info:
1716 case OPT_fopt_info_:
1717 /* Deferred. */
1718 break;
1720 case OPT_fpack_struct_:
1721 if (value <= 0 || (value & (value - 1)) || value > 16)
1722 error_at (loc,
1723 "structure alignment must be a small power of two, not %d",
1724 value);
1725 else
1726 opts->x_initial_max_fld_align = value;
1727 break;
1729 case OPT_fplugin_:
1730 case OPT_fplugin_arg_:
1731 /* Deferred. */
1732 break;
1734 case OPT_fprofile_use_:
1735 opts->x_profile_data_prefix = xstrdup (arg);
1736 opts->x_flag_profile_use = true;
1737 value = true;
1738 /* No break here - do -fprofile-use processing. */
1739 case OPT_fprofile_use:
1740 if (!opts_set->x_flag_branch_probabilities)
1741 opts->x_flag_branch_probabilities = value;
1742 if (!opts_set->x_flag_profile_values)
1743 opts->x_flag_profile_values = value;
1744 if (!opts_set->x_flag_unroll_loops)
1745 opts->x_flag_unroll_loops = value;
1746 if (!opts_set->x_flag_peel_loops)
1747 opts->x_flag_peel_loops = value;
1748 if (!opts_set->x_flag_tracer)
1749 opts->x_flag_tracer = value;
1750 if (!opts_set->x_flag_value_profile_transformations)
1751 opts->x_flag_value_profile_transformations = value;
1752 if (!opts_set->x_flag_inline_functions)
1753 opts->x_flag_inline_functions = value;
1754 if (!opts_set->x_flag_ipa_cp)
1755 opts->x_flag_ipa_cp = value;
1756 if (!opts_set->x_flag_ipa_cp_clone
1757 && value && opts->x_flag_ipa_cp)
1758 opts->x_flag_ipa_cp_clone = value;
1759 if (!opts_set->x_flag_predictive_commoning)
1760 opts->x_flag_predictive_commoning = value;
1761 if (!opts_set->x_flag_unswitch_loops)
1762 opts->x_flag_unswitch_loops = value;
1763 if (!opts_set->x_flag_gcse_after_reload)
1764 opts->x_flag_gcse_after_reload = value;
1765 if (!opts_set->x_flag_tree_loop_vectorize
1766 && !opts_set->x_flag_tree_vectorize)
1767 opts->x_flag_tree_loop_vectorize = value;
1768 if (!opts_set->x_flag_tree_slp_vectorize
1769 && !opts_set->x_flag_tree_vectorize)
1770 opts->x_flag_tree_slp_vectorize = value;
1771 if (!opts_set->x_flag_vect_cost_model)
1772 opts->x_flag_vect_cost_model = VECT_COST_MODEL_DYNAMIC;
1773 if (!opts_set->x_flag_tree_loop_distribute_patterns)
1774 opts->x_flag_tree_loop_distribute_patterns = value;
1775 if (!opts_set->x_flag_profile_reorder_functions)
1776 opts->x_flag_profile_reorder_functions = value;
1777 /* Indirect call profiling should do all useful transformations
1778 speculative devirtualization does. */
1779 if (!opts_set->x_flag_devirtualize_speculatively
1780 && opts->x_flag_value_profile_transformations)
1781 opts->x_flag_devirtualize_speculatively = false;
1782 break;
1784 case OPT_fprofile_generate_:
1785 opts->x_profile_data_prefix = xstrdup (arg);
1786 value = true;
1787 /* No break here - do -fprofile-generate processing. */
1788 case OPT_fprofile_generate:
1789 if (!opts_set->x_profile_arc_flag)
1790 opts->x_profile_arc_flag = value;
1791 if (!opts_set->x_flag_profile_values)
1792 opts->x_flag_profile_values = value;
1793 if (!opts_set->x_flag_inline_functions)
1794 opts->x_flag_inline_functions = value;
1795 /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
1796 quadratic. Disable the pass until better memory representation
1797 is done. */
1798 if (!opts_set->x_flag_ipa_reference)
1799 opts->x_flag_ipa_reference = false;
1800 break;
1802 case OPT_ftree_vectorize:
1803 if (!opts_set->x_flag_tree_loop_vectorize)
1804 opts->x_flag_tree_loop_vectorize = value;
1805 if (!opts_set->x_flag_tree_slp_vectorize)
1806 opts->x_flag_tree_slp_vectorize = value;
1807 break;
1808 case OPT_fshow_column:
1809 dc->show_column = value;
1810 break;
1812 case OPT_frandom_seed:
1813 /* The real switch is -fno-random-seed. */
1814 if (value)
1815 return false;
1816 /* Deferred. */
1817 break;
1819 case OPT_frandom_seed_:
1820 /* Deferred. */
1821 break;
1823 case OPT_fsched_verbose_:
1824 #ifdef INSN_SCHEDULING
1825 /* Handled with Var in common.opt. */
1826 break;
1827 #else
1828 return false;
1829 #endif
1831 case OPT_fsched_stalled_insns_:
1832 opts->x_flag_sched_stalled_insns = value;
1833 if (opts->x_flag_sched_stalled_insns == 0)
1834 opts->x_flag_sched_stalled_insns = -1;
1835 break;
1837 case OPT_fsched_stalled_insns_dep_:
1838 opts->x_flag_sched_stalled_insns_dep = value;
1839 break;
1841 case OPT_fstack_check_:
1842 if (!strcmp (arg, "no"))
1843 opts->x_flag_stack_check = NO_STACK_CHECK;
1844 else if (!strcmp (arg, "generic"))
1845 /* This is the old stack checking method. */
1846 opts->x_flag_stack_check = STACK_CHECK_BUILTIN
1847 ? FULL_BUILTIN_STACK_CHECK
1848 : GENERIC_STACK_CHECK;
1849 else if (!strcmp (arg, "specific"))
1850 /* This is the new stack checking method. */
1851 opts->x_flag_stack_check = STACK_CHECK_BUILTIN
1852 ? FULL_BUILTIN_STACK_CHECK
1853 : STACK_CHECK_STATIC_BUILTIN
1854 ? STATIC_BUILTIN_STACK_CHECK
1855 : GENERIC_STACK_CHECK;
1856 else
1857 warning_at (loc, 0, "unknown stack check parameter \"%s\"", arg);
1858 break;
1860 case OPT_fstack_limit:
1861 /* The real switch is -fno-stack-limit. */
1862 if (value)
1863 return false;
1864 /* Deferred. */
1865 break;
1867 case OPT_fstack_limit_register_:
1868 case OPT_fstack_limit_symbol_:
1869 /* Deferred. */
1870 break;
1872 case OPT_fstack_usage:
1873 opts->x_flag_stack_usage = value;
1874 opts->x_flag_stack_usage_info = value != 0;
1875 break;
1877 case OPT_g:
1878 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg, opts, opts_set,
1879 loc);
1880 break;
1882 case OPT_gcoff:
1883 set_debug_level (SDB_DEBUG, false, arg, opts, opts_set, loc);
1884 break;
1886 case OPT_gdwarf:
1887 if (arg && strlen (arg) != 0)
1889 error_at (loc, "%<-gdwarf%s%> is ambiguous; "
1890 "use %<-gdwarf-%s%> for DWARF version "
1891 "or %<-gdwarf -g%s%> for debug level", arg, arg, arg);
1892 break;
1894 else
1895 value = opts->x_dwarf_version;
1897 /* FALLTHRU */
1898 case OPT_gdwarf_:
1899 if (value < 2 || value > 4)
1900 error_at (loc, "dwarf version %d is not supported", value);
1901 else
1902 opts->x_dwarf_version = value;
1903 set_debug_level (DWARF2_DEBUG, false, "", opts, opts_set, loc);
1904 break;
1906 case OPT_gsplit_dwarf:
1907 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, "", opts, opts_set,
1908 loc);
1909 break;
1911 case OPT_ggdb:
1912 set_debug_level (NO_DEBUG, 2, arg, opts, opts_set, loc);
1913 break;
1915 case OPT_gstabs:
1916 case OPT_gstabs_:
1917 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg, opts, opts_set,
1918 loc);
1919 break;
1921 case OPT_gvms:
1922 set_debug_level (VMS_DEBUG, false, arg, opts, opts_set, loc);
1923 break;
1925 case OPT_gxcoff:
1926 case OPT_gxcoff_:
1927 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg, opts, opts_set,
1928 loc);
1929 break;
1931 case OPT_gz:
1932 case OPT_gz_:
1933 /* Handled completely via specs. */
1934 break;
1936 case OPT_pedantic_errors:
1937 dc->pedantic_errors = 1;
1938 control_warning_option (OPT_Wpedantic, DK_ERROR, value,
1939 loc, lang_mask,
1940 handlers, opts, opts_set,
1941 dc);
1942 break;
1944 case OPT_flto:
1945 opts->x_flag_lto = value ? "" : NULL;
1946 break;
1948 case OPT_w:
1949 dc->dc_inhibit_warnings = true;
1950 break;
1952 case OPT_fmax_errors_:
1953 dc->max_errors = value;
1954 break;
1956 case OPT_fuse_ld_bfd:
1957 case OPT_fuse_ld_gold:
1958 case OPT_fuse_linker_plugin:
1959 /* No-op. Used by the driver and passed to us because it starts with f.*/
1960 break;
1962 case OPT_fwrapv:
1963 if (value)
1964 opts->x_flag_trapv = 0;
1965 break;
1967 case OPT_ftrapv:
1968 if (value)
1969 opts->x_flag_wrapv = 0;
1970 break;
1972 default:
1973 /* If the flag was handled in a standard way, assume the lack of
1974 processing here is intentional. */
1975 gcc_assert (option_flag_var (scode, opts));
1976 break;
1979 common_handle_option_auto (opts, opts_set, decoded, lang_mask, kind,
1980 loc, handlers, dc);
1981 return true;
1984 /* Handle --param NAME=VALUE. */
1985 static void
1986 handle_param (struct gcc_options *opts, struct gcc_options *opts_set,
1987 location_t loc, const char *carg)
1989 char *equal, *arg;
1990 int value;
1992 arg = xstrdup (carg);
1993 equal = strchr (arg, '=');
1994 if (!equal)
1995 error_at (loc, "%s: --param arguments should be of the form NAME=VALUE",
1996 arg);
1997 else
1999 value = integral_argument (equal + 1);
2000 if (value == -1)
2001 error_at (loc, "invalid --param value %qs", equal + 1);
2002 else
2004 *equal = '\0';
2005 set_param_value (arg, value,
2006 opts->x_param_values, opts_set->x_param_values);
2010 free (arg);
2013 /* Used to set the level of strict aliasing warnings in OPTS,
2014 when no level is specified (i.e., when -Wstrict-aliasing, and not
2015 -Wstrict-aliasing=level was given).
2016 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2017 and 0 otherwise. After calling this function, wstrict_aliasing will be
2018 set to the default value of -Wstrict_aliasing=level, currently 3. */
2019 static void
2020 set_Wstrict_aliasing (struct gcc_options *opts, int onoff)
2022 gcc_assert (onoff == 0 || onoff == 1);
2023 if (onoff != 0)
2024 opts->x_warn_strict_aliasing = 3;
2025 else
2026 opts->x_warn_strict_aliasing = 0;
2029 /* The following routines are useful in setting all the flags that
2030 -ffast-math and -fno-fast-math imply. */
2031 static void
2032 set_fast_math_flags (struct gcc_options *opts, int set)
2034 if (!opts->frontend_set_flag_unsafe_math_optimizations)
2036 opts->x_flag_unsafe_math_optimizations = set;
2037 set_unsafe_math_optimizations_flags (opts, set);
2039 if (!opts->frontend_set_flag_finite_math_only)
2040 opts->x_flag_finite_math_only = set;
2041 if (!opts->frontend_set_flag_errno_math)
2042 opts->x_flag_errno_math = !set;
2043 if (set)
2045 if (!opts->frontend_set_flag_signaling_nans)
2046 opts->x_flag_signaling_nans = 0;
2047 if (!opts->frontend_set_flag_rounding_math)
2048 opts->x_flag_rounding_math = 0;
2049 if (!opts->frontend_set_flag_cx_limited_range)
2050 opts->x_flag_cx_limited_range = 1;
2054 /* When -funsafe-math-optimizations is set the following
2055 flags are set as well. */
2056 static void
2057 set_unsafe_math_optimizations_flags (struct gcc_options *opts, int set)
2059 if (!opts->frontend_set_flag_trapping_math)
2060 opts->x_flag_trapping_math = !set;
2061 if (!opts->frontend_set_flag_signed_zeros)
2062 opts->x_flag_signed_zeros = !set;
2063 if (!opts->frontend_set_flag_associative_math)
2064 opts->x_flag_associative_math = set;
2065 if (!opts->frontend_set_flag_reciprocal_math)
2066 opts->x_flag_reciprocal_math = set;
2069 /* Return true iff flags in OPTS are set as if -ffast-math. */
2070 bool
2071 fast_math_flags_set_p (const struct gcc_options *opts)
2073 return (!opts->x_flag_trapping_math
2074 && opts->x_flag_unsafe_math_optimizations
2075 && opts->x_flag_finite_math_only
2076 && !opts->x_flag_signed_zeros
2077 && !opts->x_flag_errno_math);
2080 /* Return true iff flags are set as if -ffast-math but using the flags stored
2081 in the struct cl_optimization structure. */
2082 bool
2083 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2085 return (!opt->x_flag_trapping_math
2086 && opt->x_flag_unsafe_math_optimizations
2087 && opt->x_flag_finite_math_only
2088 && !opt->x_flag_signed_zeros
2089 && !opt->x_flag_errno_math);
2092 /* Handle a debug output -g switch for options OPTS
2093 (OPTS_SET->x_write_symbols storing whether a debug type was passed
2094 explicitly), location LOC. EXTENDED is true or false to support
2095 extended output (2 is special and means "-ggdb" was given). */
2096 static void
2097 set_debug_level (enum debug_info_type type, int extended, const char *arg,
2098 struct gcc_options *opts, struct gcc_options *opts_set,
2099 location_t loc)
2101 opts->x_use_gnu_debug_info_extensions = extended;
2103 if (type == NO_DEBUG)
2105 if (opts->x_write_symbols == NO_DEBUG)
2107 opts->x_write_symbols = PREFERRED_DEBUGGING_TYPE;
2109 if (extended == 2)
2111 #ifdef DWARF2_DEBUGGING_INFO
2112 opts->x_write_symbols = DWARF2_DEBUG;
2113 #elif defined DBX_DEBUGGING_INFO
2114 opts->x_write_symbols = DBX_DEBUG;
2115 #endif
2118 if (opts->x_write_symbols == NO_DEBUG)
2119 warning_at (loc, 0, "target system does not support debug output");
2122 else
2124 /* Does it conflict with an already selected type? */
2125 if (opts_set->x_write_symbols != NO_DEBUG
2126 && opts->x_write_symbols != NO_DEBUG
2127 && type != opts->x_write_symbols)
2128 error_at (loc, "debug format \"%s\" conflicts with prior selection",
2129 debug_type_names[type]);
2130 opts->x_write_symbols = type;
2131 opts_set->x_write_symbols = type;
2134 /* A debug flag without a level defaults to level 2.
2135 If off or at level 1, set it to level 2, but if already
2136 at level 3, don't lower it. */
2137 if (*arg == '\0')
2139 if (opts->x_debug_info_level < DINFO_LEVEL_NORMAL)
2140 opts->x_debug_info_level = DINFO_LEVEL_NORMAL;
2142 else
2144 int argval = integral_argument (arg);
2145 if (argval == -1)
2146 error_at (loc, "unrecognised debug output level \"%s\"", arg);
2147 else if (argval > 3)
2148 error_at (loc, "debug output level %s is too high", arg);
2149 else
2150 opts->x_debug_info_level = (enum debug_info_levels) argval;
2154 /* Arrange to dump core on error for diagnostic context DC. (The
2155 regular error message is still printed first, except in the case of
2156 abort ().) */
2158 static void
2159 setup_core_dumping (diagnostic_context *dc)
2161 #ifdef SIGABRT
2162 signal (SIGABRT, SIG_DFL);
2163 #endif
2164 #if defined(HAVE_SETRLIMIT)
2166 struct rlimit rlim;
2167 if (getrlimit (RLIMIT_CORE, &rlim) != 0)
2168 fatal_error ("getting core file size maximum limit: %m");
2169 rlim.rlim_cur = rlim.rlim_max;
2170 if (setrlimit (RLIMIT_CORE, &rlim) != 0)
2171 fatal_error ("setting core file size limit to maximum: %m");
2173 #endif
2174 diagnostic_abort_on_error (dc);
2177 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
2178 diagnostic context DC. */
2180 static void
2181 decode_d_option (const char *arg, struct gcc_options *opts,
2182 location_t loc, diagnostic_context *dc)
2184 int c;
2186 while (*arg)
2187 switch (c = *arg++)
2189 case 'A':
2190 opts->x_flag_debug_asm = 1;
2191 break;
2192 case 'p':
2193 opts->x_flag_print_asm_name = 1;
2194 break;
2195 case 'P':
2196 opts->x_flag_dump_rtl_in_asm = 1;
2197 opts->x_flag_print_asm_name = 1;
2198 break;
2199 case 'x':
2200 opts->x_rtl_dump_and_exit = 1;
2201 break;
2202 case 'D': /* These are handled by the preprocessor. */
2203 case 'I':
2204 case 'M':
2205 case 'N':
2206 case 'U':
2207 break;
2208 case 'H':
2209 setup_core_dumping (dc);
2210 break;
2211 case 'a':
2212 opts->x_flag_dump_all_passed = true;
2213 break;
2215 default:
2216 warning_at (loc, 0, "unrecognized gcc debugging option: %c", c);
2217 break;
2221 /* Enable (or disable if VALUE is 0) a warning option ARG (language
2222 mask LANG_MASK, option handlers HANDLERS) as an error for option
2223 structures OPTS and OPTS_SET, diagnostic context DC (possibly
2224 NULL), location LOC. This is used by -Werror=. */
2226 static void
2227 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
2228 const struct cl_option_handlers *handlers,
2229 struct gcc_options *opts,
2230 struct gcc_options *opts_set,
2231 location_t loc, diagnostic_context *dc)
2233 char *new_option;
2234 int option_index;
2236 new_option = XNEWVEC (char, strlen (arg) + 2);
2237 new_option[0] = 'W';
2238 strcpy (new_option + 1, arg);
2239 option_index = find_opt (new_option, lang_mask);
2240 if (option_index == OPT_SPECIAL_unknown)
2242 error_at (loc, "-Werror=%s: no option -%s", arg, new_option);
2244 else
2246 const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
2248 control_warning_option (option_index, (int) kind, value,
2249 loc, lang_mask,
2250 handlers, opts, opts_set, dc);
2252 free (new_option);
2255 /* Return malloced memory for the name of the option OPTION_INDEX
2256 which enabled a diagnostic (context CONTEXT), originally of type
2257 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2258 as -Werror. */
2260 char *
2261 option_name (diagnostic_context *context, int option_index,
2262 diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
2264 if (option_index)
2266 /* A warning classified as an error. */
2267 if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
2268 && diag_kind == DK_ERROR)
2269 return concat (cl_options[OPT_Werror_].opt_text,
2270 /* Skip over "-W". */
2271 cl_options[option_index].opt_text + 2,
2272 NULL);
2273 /* A warning with option. */
2274 else
2275 return xstrdup (cl_options[option_index].opt_text);
2277 /* A warning without option classified as an error. */
2278 else if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
2279 || diag_kind == DK_WARNING)
2280 && context->warning_as_error_requested)
2281 return xstrdup (cl_options[OPT_Werror].opt_text);
2282 else
2283 return NULL;