1 /* Command line option handling.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Contributed by Neil Booth.
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/>. */
25 #include "coretypes.h"
26 #include "tm.h" /* Needed by rtl.h and used for DWARF2_DEBUGGING_INFO
27 and DBX_DEBUGGING_INFO. */
28 #include "rtl.h" /* Needed by insn-attr.h. */
33 #include "diagnostic.h"
34 #include "opts-diagnostic.h"
35 #include "insn-attr.h" /* For INSN_SCHEDULING and DELAY_SLOTS. */
38 /* Run the second compilation of -fcompare-debug. Not defined using
39 Var in common.opt because this is used in Ada code and so must be
40 an actual variable not a macro. */
41 int flag_compare_debug;
43 /* Parse the -femit-struct-debug-detailed option value
44 and set the flag variables. */
46 #define MATCH( prefix, string ) \
47 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
48 ? ((string += sizeof prefix - 1), 1) : 0)
51 set_struct_debug_option (struct gcc_options *opts, location_t loc,
54 /* various labels for comparison */
55 static const char dfn_lbl[] = "dfn:", dir_lbl[] = "dir:", ind_lbl[] = "ind:";
56 static const char ord_lbl[] = "ord:", gen_lbl[] = "gen:";
57 static const char none_lbl[] = "none", any_lbl[] = "any";
58 static const char base_lbl[] = "base", sys_lbl[] = "sys";
60 enum debug_struct_file files = DINFO_STRUCT_FILE_ANY;
61 /* Default is to apply to as much as possible. */
62 enum debug_info_usage usage = DINFO_USAGE_NUM_ENUMS;
66 if (MATCH (dfn_lbl, spec))
67 usage = DINFO_USAGE_DFN;
68 else if (MATCH (dir_lbl, spec))
69 usage = DINFO_USAGE_DIR_USE;
70 else if (MATCH (ind_lbl, spec))
71 usage = DINFO_USAGE_IND_USE;
73 /* Generics or not? */
74 if (MATCH (ord_lbl, spec))
76 else if (MATCH (gen_lbl, spec))
79 /* What allowable environment? */
80 if (MATCH (none_lbl, spec))
81 files = DINFO_STRUCT_FILE_NONE;
82 else if (MATCH (any_lbl, spec))
83 files = DINFO_STRUCT_FILE_ANY;
84 else if (MATCH (sys_lbl, spec))
85 files = DINFO_STRUCT_FILE_SYS;
86 else if (MATCH (base_lbl, spec))
87 files = DINFO_STRUCT_FILE_BASE;
90 "argument %qs to %<-femit-struct-debug-detailed%> "
94 /* Effect the specification. */
95 if (usage == DINFO_USAGE_NUM_ENUMS)
99 opts->x_debug_struct_ordinary[DINFO_USAGE_DFN] = files;
100 opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE] = files;
101 opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE] = files;
105 opts->x_debug_struct_generic[DINFO_USAGE_DFN] = files;
106 opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE] = files;
107 opts->x_debug_struct_generic[DINFO_USAGE_IND_USE] = files;
113 opts->x_debug_struct_ordinary[usage] = files;
115 opts->x_debug_struct_generic[usage] = files;
119 set_struct_debug_option (opts, loc, spec+1);
122 /* No more -femit-struct-debug-detailed specifications.
126 "argument %qs to %<-femit-struct-debug-detailed%> unknown",
128 if (opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE]
129 < opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE]
130 || opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE]
131 < opts->x_debug_struct_generic[DINFO_USAGE_IND_USE])
133 "%<-femit-struct-debug-detailed=dir:...%> must allow "
134 "at least as much as "
135 "%<-femit-struct-debug-detailed=ind:...%>");
139 /* Handle -ftree-vectorizer-verbose=VAL for options OPTS. */
142 vect_set_verbosity_level (struct gcc_options *opts, int val)
144 if (val < MAX_VERBOSITY_LEVEL)
145 opts->x_user_vect_verbosity_level = (enum vect_verbosity_levels) val;
147 opts->x_user_vect_verbosity_level
148 = (enum vect_verbosity_levels) (MAX_VERBOSITY_LEVEL - 1);
152 /* Strip off a legitimate source ending from the input string NAME of
153 length LEN. Rather than having to know the names used by all of
154 our front ends, we strip off an ending of a period followed by
155 up to five characters. (Java uses ".class".) */
158 strip_off_ending (char *name, int len)
161 for (i = 2; i < 6 && len > i; i++)
163 if (name[len - i] == '.')
165 name[len - i] = '\0';
171 /* Find the base name of a path, stripping off both directories and
172 a single final extension. */
174 base_of_path (const char *path, const char **base_out)
176 const char *base = path;
178 const char *p = path;
182 if (IS_DIR_SEPARATOR(c))
197 /* What to print when a switch has no documentation. */
198 static const char undocumented_msg[] = N_("This switch lacks documentation");
200 typedef char *char_p; /* For DEF_VEC_P. */
202 DEF_VEC_ALLOC_P(char_p,heap);
204 static void handle_param (struct gcc_options *opts,
205 struct gcc_options *opts_set, location_t loc,
207 static void set_debug_level (enum debug_info_type type, int extended,
208 const char *arg, struct gcc_options *opts,
209 struct gcc_options *opts_set,
211 static void set_fast_math_flags (struct gcc_options *opts, int set);
212 static void decode_d_option (const char *arg, struct gcc_options *opts,
213 location_t loc, diagnostic_context *dc);
214 static void set_unsafe_math_optimizations_flags (struct gcc_options *opts,
216 static void enable_warning_as_error (const char *arg, int value,
217 unsigned int lang_mask,
218 const struct cl_option_handlers *handlers,
219 struct gcc_options *opts,
220 struct gcc_options *opts_set,
222 diagnostic_context *dc);
224 /* Handle a back-end option; arguments and return value as for
228 target_handle_option (struct gcc_options *opts,
229 struct gcc_options *opts_set,
230 const struct cl_decoded_option *decoded,
231 unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
232 location_t loc ATTRIBUTE_UNUSED,
233 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
234 diagnostic_context *dc)
236 gcc_assert (opts == &global_options);
237 gcc_assert (opts_set == &global_options_set);
238 gcc_assert (dc == global_dc);
239 gcc_assert (decoded->canonical_option_num_elements <= 2);
240 gcc_assert (kind == DK_UNSPECIFIED);
241 /* Although the location is not passed down to
242 targetm.handle_option, do not make assertions about its value;
243 options may come from optimize attributes and having the correct
244 location in the handler is not generally important. */
245 return targetm.handle_option (decoded->opt_index, decoded->arg,
249 /* Add comma-separated strings to a char_p vector. */
252 add_comma_separated_to_vector (void **pvec, const char *arg)
258 VEC(char_p,heap) *vec = (VEC(char_p,heap) *) *pvec;
260 /* We never free this string. */
273 VEC_safe_push (char_p, heap, vec, token_start);
276 if (*r == '\\' && r[1] == ',')
284 if (*token_start != '\0')
285 VEC_safe_push (char_p, heap, vec, token_start);
290 /* Initialize OPTS and OPTS_SET before using them in parsing options. */
293 init_options_struct (struct gcc_options *opts, struct gcc_options *opts_set)
295 size_t num_params = get_num_compiler_params ();
297 *opts = global_options_init;
298 memset (opts_set, 0, sizeof (*opts_set));
300 opts->x_param_values = XNEWVEC (int, num_params);
301 opts_set->x_param_values = XCNEWVEC (int, num_params);
302 init_param_values (opts->x_param_values);
304 /* Use priority coloring if cover classes is not defined for the
306 if (targetm.ira_cover_classes == NULL)
307 opts->x_flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
309 /* Initialize whether `char' is signed. */
310 opts->x_flag_signed_char = DEFAULT_SIGNED_CHAR;
311 /* Set this to a special "uninitialized" value. The actual default
312 is set after target options have been processed. */
313 opts->x_flag_short_enums = 2;
315 /* Initialize target_flags before targetm.target_option.optimization
316 so the latter can modify it. */
317 opts->x_target_flags = targetm.default_target_flags;
319 /* Some targets have ABI-specified unwind tables. */
320 opts->x_flag_unwind_tables = targetm.unwind_tables_default;
322 /* Some targets have other target-specific initialization. */
323 targetm.target_option.init_struct (opts);
326 /* If indicated by the optimization level LEVEL (-Os if SIZE is set,
327 -Ofast if FAST is set), apply the option DEFAULT_OPT to OPTS and
328 OPTS_SET, diagnostic context DC, location LOC, with language mask
329 LANG_MASK and option handlers HANDLERS. */
332 maybe_default_option (struct gcc_options *opts,
333 struct gcc_options *opts_set,
334 const struct default_options *default_opt,
335 int level, bool size, bool fast,
336 unsigned int lang_mask,
337 const struct cl_option_handlers *handlers,
339 diagnostic_context *dc)
341 const struct cl_option *option = &cl_options[default_opt->opt_index];
345 gcc_assert (level == 2);
347 gcc_assert (level == 3);
349 switch (default_opt->levels)
355 case OPT_LEVELS_0_ONLY:
356 enabled = (level == 0);
359 case OPT_LEVELS_1_PLUS:
360 enabled = (level >= 1);
363 case OPT_LEVELS_1_PLUS_SPEED_ONLY:
364 enabled = (level >= 1 && !size);
367 case OPT_LEVELS_2_PLUS:
368 enabled = (level >= 2);
371 case OPT_LEVELS_2_PLUS_SPEED_ONLY:
372 enabled = (level >= 2 && !size);
375 case OPT_LEVELS_3_PLUS:
376 enabled = (level >= 3);
379 case OPT_LEVELS_3_PLUS_AND_SIZE:
380 enabled = (level >= 3 || size);
383 case OPT_LEVELS_SIZE:
387 case OPT_LEVELS_FAST:
391 case OPT_LEVELS_NONE:
397 handle_generated_option (opts, opts_set, default_opt->opt_index,
398 default_opt->arg, default_opt->value,
399 lang_mask, DK_UNSPECIFIED, loc,
401 else if (default_opt->arg == NULL
402 && !(option->flags & CL_REJECT_NEGATIVE))
403 handle_generated_option (opts, opts_set, default_opt->opt_index,
404 default_opt->arg, !default_opt->value,
405 lang_mask, DK_UNSPECIFIED, loc,
409 /* As indicated by the optimization level LEVEL (-Os if SIZE is set,
410 -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
411 OPTS and OPTS_SET, diagnostic context DC, location LOC, with
412 language mask LANG_MASK and option handlers HANDLERS. */
415 maybe_default_options (struct gcc_options *opts,
416 struct gcc_options *opts_set,
417 const struct default_options *default_opts,
418 int level, bool size, bool fast,
419 unsigned int lang_mask,
420 const struct cl_option_handlers *handlers,
422 diagnostic_context *dc)
426 for (i = 0; default_opts[i].levels != OPT_LEVELS_NONE; i++)
427 maybe_default_option (opts, opts_set, &default_opts[i],
428 level, size, fast, lang_mask, handlers, loc, dc);
431 /* Table of options enabled by default at different levels. */
433 static const struct default_options default_options_table[] =
435 /* -O1 optimizations. */
436 { OPT_LEVELS_1_PLUS, OPT_fdefer_pop, NULL, 1 },
438 { OPT_LEVELS_1_PLUS, OPT_fdelayed_branch, NULL, 1 },
440 { OPT_LEVELS_1_PLUS, OPT_fguess_branch_probability, NULL, 1 },
441 { OPT_LEVELS_1_PLUS, OPT_fcprop_registers, NULL, 1 },
442 { OPT_LEVELS_1_PLUS, OPT_fforward_propagate, NULL, 1 },
443 { OPT_LEVELS_1_PLUS, OPT_fif_conversion, NULL, 1 },
444 { OPT_LEVELS_1_PLUS, OPT_fif_conversion2, NULL, 1 },
445 { OPT_LEVELS_1_PLUS, OPT_fipa_pure_const, NULL, 1 },
446 { OPT_LEVELS_1_PLUS, OPT_fipa_reference, NULL, 1 },
447 { OPT_LEVELS_1_PLUS, OPT_fipa_profile, NULL, 1 },
448 { OPT_LEVELS_1_PLUS, OPT_fmerge_constants, NULL, 1 },
449 { OPT_LEVELS_1_PLUS, OPT_fsplit_wide_types, NULL, 1 },
450 { OPT_LEVELS_1_PLUS, OPT_ftree_ccp, NULL, 1 },
451 { OPT_LEVELS_1_PLUS, OPT_ftree_bit_ccp, NULL, 1 },
452 { OPT_LEVELS_1_PLUS, OPT_ftree_dce, NULL, 1 },
453 { OPT_LEVELS_1_PLUS, OPT_ftree_dominator_opts, NULL, 1 },
454 { OPT_LEVELS_1_PLUS, OPT_ftree_dse, NULL, 1 },
455 { OPT_LEVELS_1_PLUS, OPT_ftree_ter, NULL, 1 },
456 { OPT_LEVELS_1_PLUS, OPT_ftree_sra, NULL, 1 },
457 { OPT_LEVELS_1_PLUS, OPT_ftree_copyrename, NULL, 1 },
458 { OPT_LEVELS_1_PLUS, OPT_ftree_fre, NULL, 1 },
459 { OPT_LEVELS_1_PLUS, OPT_ftree_copy_prop, NULL, 1 },
460 { OPT_LEVELS_1_PLUS, OPT_ftree_sink, NULL, 1 },
461 { OPT_LEVELS_1_PLUS, OPT_ftree_ch, NULL, 1 },
462 { OPT_LEVELS_1_PLUS, OPT_fcombine_stack_adjustments, NULL, 1 },
464 /* -O2 optimizations. */
465 { OPT_LEVELS_2_PLUS, OPT_finline_small_functions, NULL, 1 },
466 { OPT_LEVELS_2_PLUS, OPT_findirect_inlining, NULL, 1 },
467 { OPT_LEVELS_2_PLUS, OPT_fpartial_inlining, NULL, 1 },
468 { OPT_LEVELS_2_PLUS, OPT_fthread_jumps, NULL, 1 },
469 { OPT_LEVELS_2_PLUS, OPT_fcrossjumping, NULL, 1 },
470 { OPT_LEVELS_2_PLUS, OPT_foptimize_sibling_calls, NULL, 1 },
471 { OPT_LEVELS_2_PLUS, OPT_fcse_follow_jumps, NULL, 1 },
472 { OPT_LEVELS_2_PLUS, OPT_fgcse, NULL, 1 },
473 { OPT_LEVELS_2_PLUS, OPT_fexpensive_optimizations, NULL, 1 },
474 { OPT_LEVELS_2_PLUS, OPT_frerun_cse_after_loop, NULL, 1 },
475 { OPT_LEVELS_2_PLUS, OPT_fcaller_saves, NULL, 1 },
476 { OPT_LEVELS_2_PLUS, OPT_fpeephole2, NULL, 1 },
477 #ifdef INSN_SCHEDULING
478 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
479 { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_fschedule_insns, NULL, 1 },
480 { OPT_LEVELS_2_PLUS, OPT_fschedule_insns2, NULL, 1 },
482 { OPT_LEVELS_2_PLUS, OPT_fregmove, NULL, 1 },
483 { OPT_LEVELS_2_PLUS, OPT_fstrict_aliasing, NULL, 1 },
484 { OPT_LEVELS_2_PLUS, OPT_fstrict_overflow, NULL, 1 },
485 { OPT_LEVELS_2_PLUS, OPT_freorder_blocks, NULL, 1 },
486 { OPT_LEVELS_2_PLUS, OPT_freorder_functions, NULL, 1 },
487 { OPT_LEVELS_2_PLUS, OPT_ftree_vrp, NULL, 1 },
488 { OPT_LEVELS_2_PLUS, OPT_ftree_builtin_call_dce, NULL, 1 },
489 { OPT_LEVELS_2_PLUS, OPT_ftree_pre, NULL, 1 },
490 { OPT_LEVELS_2_PLUS, OPT_ftree_switch_conversion, NULL, 1 },
491 { OPT_LEVELS_2_PLUS, OPT_fipa_cp, NULL, 1 },
492 { OPT_LEVELS_2_PLUS, OPT_fipa_sra, NULL, 1 },
493 { OPT_LEVELS_2_PLUS, OPT_falign_loops, NULL, 1 },
494 { OPT_LEVELS_2_PLUS, OPT_falign_jumps, NULL, 1 },
495 { OPT_LEVELS_2_PLUS, OPT_falign_labels, NULL, 1 },
496 { OPT_LEVELS_2_PLUS, OPT_falign_functions, NULL, 1 },
498 /* -O3 optimizations. */
499 { OPT_LEVELS_3_PLUS, OPT_ftree_loop_distribute_patterns, NULL, 1 },
500 { OPT_LEVELS_3_PLUS, OPT_fpredictive_commoning, NULL, 1 },
501 /* Inlining of functions reducing size is a good idea with -Os
502 regardless of them being declared inline. */
503 { OPT_LEVELS_3_PLUS_AND_SIZE, OPT_finline_functions, NULL, 1 },
504 { OPT_LEVELS_3_PLUS, OPT_funswitch_loops, NULL, 1 },
505 { OPT_LEVELS_3_PLUS, OPT_fgcse_after_reload, NULL, 1 },
506 { OPT_LEVELS_3_PLUS, OPT_ftree_vectorize, NULL, 1 },
507 { OPT_LEVELS_3_PLUS, OPT_fipa_cp_clone, NULL, 1 },
509 /* -Ofast adds optimizations to -O3. */
510 { OPT_LEVELS_FAST, OPT_ffast_math, NULL, 1 },
512 { OPT_LEVELS_NONE, 0, NULL, 0 }
515 /* Default the options in OPTS and OPTS_SET based on the optimization
516 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
518 default_options_optimization (struct gcc_options *opts,
519 struct gcc_options *opts_set,
520 struct cl_decoded_option *decoded_options,
521 unsigned int decoded_options_count,
523 unsigned int lang_mask,
524 const struct cl_option_handlers *handlers,
525 diagnostic_context *dc)
531 /* Scan to see what optimization level has been specified. That will
532 determine the default value of many flags. */
533 for (i = 1; i < decoded_options_count; i++)
535 struct cl_decoded_option *opt = &decoded_options[i];
536 switch (opt->opt_index)
539 if (*opt->arg == '\0')
541 opts->x_optimize = 1;
542 opts->x_optimize_size = 0;
547 const int optimize_val = integral_argument (opt->arg);
548 if (optimize_val == -1)
550 "argument to %qs should be a non-negative integer",
554 opts->x_optimize = optimize_val;
555 if ((unsigned int) opts->x_optimize > 255)
556 opts->x_optimize = 255;
557 opts->x_optimize_size = 0;
564 opts->x_optimize_size = 1;
566 /* Optimizing for size forces optimize to be 2. */
567 opts->x_optimize = 2;
572 /* -Ofast only adds flags to -O3. */
573 opts->x_optimize_size = 0;
574 opts->x_optimize = 3;
579 /* Ignore other options in this prescan. */
584 maybe_default_options (opts, opts_set, default_options_table,
585 opts->x_optimize, opts->x_optimize_size,
586 ofast, lang_mask, handlers, loc, dc);
588 /* -O2 param settings. */
589 opt2 = (opts->x_optimize >= 2);
591 /* Track fields in field-sensitive alias analysis. */
592 maybe_set_param_value
593 (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE,
594 opt2 ? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE),
595 opts->x_param_values, opts_set->x_param_values);
597 /* For -O1 only do loop invariant motion for very small loops. */
598 maybe_set_param_value
599 (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP,
600 opt2 ? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP) : 1000,
601 opts->x_param_values, opts_set->x_param_values);
603 if (opts->x_optimize_size)
604 /* We want to crossjump as much as possible. */
605 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS, 1,
606 opts->x_param_values, opts_set->x_param_values);
608 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS,
609 default_param_value (PARAM_MIN_CROSSJUMP_INSNS),
610 opts->x_param_values, opts_set->x_param_values);
612 /* Allow default optimizations to be specified on a per-machine basis. */
613 maybe_default_options (opts, opts_set,
614 targetm.target_option.optimization_table,
615 opts->x_optimize, opts->x_optimize_size,
616 ofast, lang_mask, handlers, loc, dc);
619 /* After all options at LOC have been read into OPTS and OPTS_SET,
620 finalize settings of those options and diagnose incompatible
623 finish_options (struct gcc_options *opts, struct gcc_options *opts_set,
626 enum unwind_info_type ui_except;
628 if (opts->x_dump_base_name && ! IS_ABSOLUTE_PATH (opts->x_dump_base_name))
630 /* First try to make OPTS->X_DUMP_BASE_NAME relative to the
631 OPTS->X_DUMP_DIR_NAME directory. Then try to make
632 OPTS->X_DUMP_BASE_NAME relative to the OPTS->X_AUX_BASE_NAME
633 directory, typically the directory to contain the object
635 if (opts->x_dump_dir_name)
636 opts->x_dump_base_name = concat (opts->x_dump_dir_name,
637 opts->x_dump_base_name, NULL);
638 else if (opts->x_aux_base_name)
640 const char *aux_base;
642 base_of_path (opts->x_aux_base_name, &aux_base);
643 if (opts->x_aux_base_name != aux_base)
645 int dir_len = aux_base - opts->x_aux_base_name;
646 char *new_dump_base_name =
647 XNEWVEC (char, strlen (opts->x_dump_base_name) + dir_len + 1);
649 /* Copy directory component from OPTS->X_AUX_BASE_NAME. */
650 memcpy (new_dump_base_name, opts->x_aux_base_name, dir_len);
651 /* Append existing OPTS->X_DUMP_BASE_NAME. */
652 strcpy (new_dump_base_name + dir_len, opts->x_dump_base_name);
653 opts->x_dump_base_name = new_dump_base_name;
658 /* Handle related options for unit-at-a-time, toplevel-reorder, and
660 if (!opts->x_flag_unit_at_a_time)
662 if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
663 error_at (loc, "section anchors must be disabled when unit-at-a-time "
665 opts->x_flag_section_anchors = 0;
666 if (opts->x_flag_toplevel_reorder == 1)
667 error_at (loc, "toplevel reorder must be disabled when unit-at-a-time "
669 opts->x_flag_toplevel_reorder = 0;
672 /* -Wmissing-noreturn is alias for -Wsuggest-attribute=noreturn. */
673 if (opts->x_warn_missing_noreturn)
674 opts->x_warn_suggest_attribute_noreturn = true;
676 /* Unless the user has asked for section anchors, we disable toplevel
677 reordering at -O0 to disable transformations that might be surprising
678 to end users and to get -fno-toplevel-reorder tested. */
679 if (!opts->x_optimize
680 && opts->x_flag_toplevel_reorder == 2
681 && !(opts->x_flag_section_anchors && opts_set->x_flag_section_anchors))
683 opts->x_flag_toplevel_reorder = 0;
684 opts->x_flag_section_anchors = 0;
686 if (!opts->x_flag_toplevel_reorder)
688 if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
689 error_at (loc, "section anchors must be disabled when toplevel reorder"
691 opts->x_flag_section_anchors = 0;
694 if (!opts->x_flag_opts_finished)
696 if (opts->x_flag_pie)
697 opts->x_flag_pic = opts->x_flag_pie;
698 if (opts->x_flag_pic && !opts->x_flag_pie)
699 opts->x_flag_shlib = 1;
700 opts->x_flag_opts_finished = false;
703 if (opts->x_optimize == 0)
705 /* Inlining does not work if not optimizing,
706 so force it not to be done. */
707 opts->x_warn_inline = 0;
708 opts->x_flag_no_inline = 1;
711 /* The optimization to partition hot and cold basic blocks into separate
712 sections of the .o and executable files does not work (currently)
713 with exception handling. This is because there is no support for
714 generating unwind info. If opts->x_flag_exceptions is turned on
715 we need to turn off the partitioning optimization. */
717 ui_except = targetm.except_unwind_info (opts);
719 if (opts->x_flag_exceptions
720 && opts->x_flag_reorder_blocks_and_partition
721 && (ui_except == UI_SJLJ || ui_except == UI_TARGET))
724 "-freorder-blocks-and-partition does not work "
725 "with exceptions on this architecture");
726 opts->x_flag_reorder_blocks_and_partition = 0;
727 opts->x_flag_reorder_blocks = 1;
730 /* If user requested unwind info, then turn off the partitioning
733 if (opts->x_flag_unwind_tables
734 && !targetm.unwind_tables_default
735 && opts->x_flag_reorder_blocks_and_partition
736 && (ui_except == UI_SJLJ || ui_except == UI_TARGET))
739 "-freorder-blocks-and-partition does not support "
740 "unwind info on this architecture");
741 opts->x_flag_reorder_blocks_and_partition = 0;
742 opts->x_flag_reorder_blocks = 1;
745 /* If the target requested unwind info, then turn off the partitioning
746 optimization with a different message. Likewise, if the target does not
747 support named sections. */
749 if (opts->x_flag_reorder_blocks_and_partition
750 && (!targetm.have_named_sections
751 || (opts->x_flag_unwind_tables
752 && targetm.unwind_tables_default
753 && (ui_except == UI_SJLJ || ui_except == UI_TARGET))))
756 "-freorder-blocks-and-partition does not work "
757 "on this architecture");
758 opts->x_flag_reorder_blocks_and_partition = 0;
759 opts->x_flag_reorder_blocks = 1;
762 /* Pipelining of outer loops is only possible when general pipelining
763 capabilities are requested. */
764 if (!opts->x_flag_sel_sched_pipelining)
765 opts->x_flag_sel_sched_pipelining_outer_loops = 0;
767 if (!targetm.ira_cover_classes
768 && opts->x_flag_ira_algorithm == IRA_ALGORITHM_CB)
771 "-fira-algorithm=CB does not work on this architecture");
772 opts->x_flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
775 if (opts->x_flag_conserve_stack)
777 maybe_set_param_value (PARAM_LARGE_STACK_FRAME, 100,
778 opts->x_param_values, opts_set->x_param_values);
779 maybe_set_param_value (PARAM_STACK_FRAME_GROWTH, 40,
780 opts->x_param_values, opts_set->x_param_values);
782 if (opts->x_flag_wpa || opts->x_flag_ltrans)
784 /* These passes are not WHOPR compatible yet. */
785 opts->x_flag_ipa_pta = 0;
786 opts->x_flag_ipa_struct_reorg = 0;
789 if (opts->x_flag_lto)
792 opts->x_flag_generate_lto = 1;
794 /* When generating IL, do not operate in whole-program mode.
795 Otherwise, symbols will be privatized too early, causing link
797 opts->x_flag_whole_program = 0;
799 error_at (loc, "LTO support has not been enabled in this configuration");
802 if ((opts->x_flag_lto_partition_balanced != 0) + (opts->x_flag_lto_partition_1to1 != 0)
803 + (opts->x_flag_lto_partition_none != 0) >= 1)
805 if ((opts->x_flag_lto_partition_balanced != 0)
806 + (opts->x_flag_lto_partition_1to1 != 0)
807 + (opts->x_flag_lto_partition_none != 0) > 1)
808 error_at (loc, "only one -flto-partition value can be specified");
811 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
812 default value if they choose based on other options. */
813 if (opts->x_flag_split_stack == -1)
814 opts->x_flag_split_stack = 0;
815 else if (opts->x_flag_split_stack)
817 if (!targetm.supports_split_stack (true, opts))
819 error_at (loc, "%<-fsplit-stack%> is not supported by "
820 "this compiler configuration");
821 opts->x_flag_split_stack = 0;
826 #define LEFT_COLUMN 27
828 /* Output ITEM, of length ITEM_WIDTH, in the left column,
829 followed by word-wrapped HELP in a second column. */
831 wrap_help (const char *help,
833 unsigned int item_width,
834 unsigned int columns)
836 unsigned int col_width = LEFT_COLUMN;
837 unsigned int remaining, room, len;
839 remaining = strlen (help);
843 room = columns - 3 - MAX (col_width, item_width);
852 for (i = 0; help[i]; i++)
854 if (i >= room && len != remaining)
858 else if ((help[i] == '-' || help[i] == '/')
859 && help[i + 1] != ' '
860 && i > 0 && ISALPHA (help[i - 1]))
865 printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
867 while (help[len] == ' ')
875 /* Print help for a specific front-end, etc. */
877 print_filtered_help (unsigned int include_flags,
878 unsigned int exclude_flags,
879 unsigned int any_flags,
880 unsigned int columns,
881 struct gcc_options *opts,
882 unsigned int lang_mask)
887 bool displayed = false;
889 if (include_flags == CL_PARAMS)
891 for (i = 0; i < LAST_PARAM; i++)
893 const char *param = compiler_params[i].option;
895 help = compiler_params[i].help;
896 if (help == NULL || *help == '\0')
898 if (exclude_flags & CL_UNDOCUMENTED)
900 help = undocumented_msg;
903 /* Get the translation. */
906 wrap_help (help, param, strlen (param), columns);
912 if (!opts->x_help_printed)
913 opts->x_help_printed = XCNEWVAR (char, cl_options_count);
915 if (!opts->x_help_enum_printed)
916 opts->x_help_enum_printed = XCNEWVAR (char, cl_enums_count);
918 for (i = 0; i < cl_options_count; i++)
921 const struct cl_option *option = cl_options + i;
926 if (include_flags == 0
927 || ((option->flags & include_flags) != include_flags))
929 if ((option->flags & any_flags) == 0)
933 /* Skip unwanted switches. */
934 if ((option->flags & exclude_flags) != 0)
937 /* The driver currently prints its own help text. */
938 if ((option->flags & CL_DRIVER) != 0
939 && (option->flags & (((1U << cl_lang_count) - 1)
940 | CL_COMMON | CL_TARGET)) == 0)
944 /* Skip switches that have already been printed. */
945 if (opts->x_help_printed[i])
948 opts->x_help_printed[i] = true;
953 if (exclude_flags & CL_UNDOCUMENTED)
955 help = undocumented_msg;
958 /* Get the translation. */
961 /* Find the gap between the name of the
962 option and its descriptive text. */
963 tab = strchr (help, '\t');
972 opt = option->opt_text;
976 /* With the -Q option enabled we change the descriptive text associated
977 with an option to be an indication of its current setting. */
980 void *flag_var = option_flag_var (i, opts);
982 if (len < (LEFT_COLUMN + 2))
983 strcpy (new_help, "\t\t");
985 strcpy (new_help, "\t");
988 && option->var_type != CLVC_DEFER)
990 if (option->flags & CL_JOINED)
992 if (option->var_type == CLVC_STRING)
994 if (* (const char **) flag_var != NULL)
995 snprintf (new_help + strlen (new_help),
996 sizeof (new_help) - strlen (new_help),
997 * (const char **) flag_var);
999 else if (option->var_type == CLVC_ENUM)
1001 const struct cl_enum *e = &cl_enums[option->var_enum];
1003 const char *arg = NULL;
1005 value = e->get (flag_var);
1006 enum_value_to_arg (e->values, &arg, value, lang_mask);
1008 arg = _("[default]");
1009 snprintf (new_help + strlen (new_help),
1010 sizeof (new_help) - strlen (new_help),
1014 sprintf (new_help + strlen (new_help),
1015 "%#x", * (int *) flag_var);
1018 strcat (new_help, option_enabled (i, opts)
1019 ? _("[enabled]") : _("[disabled]"));
1025 wrap_help (help, opt, len, columns);
1028 if (option->var_type == CLVC_ENUM
1029 && opts->x_help_enum_printed[option->var_enum] != 2)
1030 opts->x_help_enum_printed[option->var_enum] = 1;
1035 unsigned int langs = include_flags & CL_LANG_ALL;
1038 printf (_(" No options with the desired characteristics were found\n"));
1043 /* PR 31349: Tell the user how to see all of the
1044 options supported by a specific front end. */
1045 for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1046 if ((1U << i) & langs)
1047 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end\n"),
1048 lang_names[i], lang_names[i]);
1052 else if (! displayed)
1053 printf (_(" All options with the desired characteristics have already been displayed\n"));
1057 /* Print details of enumerated option arguments, if those
1058 enumerations have help text headings provided. If no help text
1059 is provided, presume that the possible values are listed in the
1060 help text for the relevant options. */
1061 for (i = 0; i < cl_enums_count; i++)
1063 unsigned int j, pos;
1065 if (opts->x_help_enum_printed[i] != 1)
1067 if (cl_enums[i].help == NULL)
1069 printf (" %s\n ", _(cl_enums[i].help));
1071 for (j = 0; cl_enums[i].values[j].arg != NULL; j++)
1073 unsigned int len = strlen (cl_enums[i].values[j].arg);
1075 if (pos > 4 && pos + 1 + len <= columns)
1077 printf (" %s", cl_enums[i].values[j].arg);
1087 printf ("%s", cl_enums[i].values[j].arg);
1092 opts->x_help_enum_printed[i] = 2;
1096 /* Display help for a specified type of option.
1097 The options must have ALL of the INCLUDE_FLAGS set
1098 ANY of the flags in the ANY_FLAGS set
1099 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1100 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1102 print_specific_help (unsigned int include_flags,
1103 unsigned int exclude_flags,
1104 unsigned int any_flags,
1105 struct gcc_options *opts,
1106 unsigned int lang_mask)
1108 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1109 const char * description = NULL;
1110 const char * descrip_extra = "";
1114 /* Sanity check: Make sure that we do not have more
1115 languages than we have bits available to enumerate them. */
1116 gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
1118 /* If we have not done so already, obtain
1119 the desired maximum width of the output. */
1120 if (opts->x_help_columns == 0)
1124 p = getenv ("COLUMNS");
1127 int value = atoi (p);
1130 opts->x_help_columns = value;
1133 if (opts->x_help_columns == 0)
1134 /* Use a reasonable default. */
1135 opts->x_help_columns = 80;
1138 /* Decide upon the title for the options that we are going to display. */
1139 for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1141 switch (flag & include_flags)
1148 description = _("The following options are target specific");
1151 description = _("The following options control compiler warning messages");
1153 case CL_OPTIMIZATION:
1154 description = _("The following options control optimizations");
1157 description = _("The following options are language-independent");
1160 description = _("The --param option recognizes the following as parameters");
1163 if (i >= cl_lang_count)
1165 if (exclude_flags & all_langs_mask)
1166 description = _("The following options are specific to just the language ");
1168 description = _("The following options are supported by the language ");
1169 descrip_extra = lang_names [i];
1174 if (description == NULL)
1178 if (include_flags & CL_UNDOCUMENTED)
1179 description = _("The following options are not documented");
1180 else if (include_flags & CL_SEPARATE)
1181 description = _("The following options take separate arguments");
1182 else if (include_flags & CL_JOINED)
1183 description = _("The following options take joined arguments");
1186 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1193 if (any_flags & all_langs_mask)
1194 description = _("The following options are language-related");
1196 description = _("The following options are language-independent");
1200 printf ("%s%s:\n", description, descrip_extra);
1201 print_filtered_help (include_flags, exclude_flags, any_flags,
1202 opts->x_help_columns, opts, lang_mask);
1205 /* Handle target- and language-independent options. Return zero to
1206 generate an "unknown option" message. Only options that need
1207 extra handling need to be listed here; if you simply want
1208 DECODED->value assigned to a variable, it happens automatically. */
1211 common_handle_option (struct gcc_options *opts,
1212 struct gcc_options *opts_set,
1213 const struct cl_decoded_option *decoded,
1214 unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
1216 const struct cl_option_handlers *handlers,
1217 diagnostic_context *dc)
1219 size_t scode = decoded->opt_index;
1220 const char *arg = decoded->arg;
1221 int value = decoded->value;
1222 enum opt_code code = (enum opt_code) scode;
1224 gcc_assert (decoded->canonical_option_num_elements <= 2);
1229 handle_param (opts, opts_set, loc, arg);
1234 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1235 unsigned int undoc_mask;
1238 undoc_mask = ((opts->x_verbose_flag | opts->x_extra_warnings)
1241 /* First display any single language specific options. */
1242 for (i = 0; i < cl_lang_count; i++)
1244 (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0, opts,
1246 /* Next display any multi language specific options. */
1247 print_specific_help (0, undoc_mask, all_langs_mask, opts, lang_mask);
1248 /* Then display any remaining, non-language options. */
1249 for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1251 print_specific_help (i, undoc_mask, 0, opts, lang_mask);
1252 opts->x_exit_after_options = true;
1256 case OPT__target_help:
1257 print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0, opts, lang_mask);
1258 opts->x_exit_after_options = true;
1260 /* Allow the target a chance to give the user some additional information. */
1267 const char * a = arg;
1268 unsigned int include_flags = 0;
1269 /* Note - by default we include undocumented options when listing
1270 specific classes. If you only want to see documented options
1271 then add ",^undocumented" to the --help= option. E.g.:
1273 --help=target,^undocumented */
1274 unsigned int exclude_flags = 0;
1276 /* Walk along the argument string, parsing each word in turn.
1278 arg = [^]{word}[,{arg}]
1279 word = {optimizers|target|warnings|undocumented|
1280 params|common|<language>} */
1285 const char * string;
1290 { "optimizers", CL_OPTIMIZATION },
1291 { "target", CL_TARGET },
1292 { "warnings", CL_WARNING },
1293 { "undocumented", CL_UNDOCUMENTED },
1294 { "params", CL_PARAMS },
1295 { "joined", CL_JOINED },
1296 { "separate", CL_SEPARATE },
1297 { "common", CL_COMMON },
1300 unsigned int * pflags;
1302 unsigned int lang_flag, specific_flag;
1309 pflags = & exclude_flags;
1312 pflags = & include_flags;
1314 comma = strchr (a, ',');
1325 /* Check to see if the string matches an option class name. */
1326 for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1327 if (strncasecmp (a, specifics[i].string, len) == 0)
1329 specific_flag = specifics[i].flag;
1333 /* Check to see if the string matches a language name.
1334 Note - we rely upon the alpha-sorted nature of the entries in
1335 the lang_names array, specifically that shorter names appear
1336 before their longer variants. (i.e. C before C++). That way
1337 when we are attempting to match --help=c for example we will
1338 match with C first and not C++. */
1339 for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1340 if (strncasecmp (a, lang_names[i], len) == 0)
1342 lang_flag = 1U << i;
1346 if (specific_flag != 0)
1349 * pflags |= specific_flag;
1352 /* The option's argument matches both the start of a
1353 language name and the start of an option class name.
1354 We have a special case for when the user has
1355 specified "--help=c", but otherwise we have to issue
1357 if (strncasecmp (a, "c", len) == 0)
1358 * pflags |= lang_flag;
1361 "--help argument %q.*s is ambiguous, "
1362 "please be more specific",
1366 else if (lang_flag != 0)
1367 * pflags |= lang_flag;
1370 "unrecognized argument to --help= option: %q.*s",
1379 print_specific_help (include_flags, exclude_flags, 0, opts,
1381 opts->x_exit_after_options = true;
1386 opts->x_exit_after_options = true;
1392 /* Currently handled in a prescan. */
1396 enable_warning_as_error (arg, value, lang_mask, handlers,
1397 opts, opts_set, loc, dc);
1400 case OPT_Wlarger_than_:
1401 opts->x_larger_than_size = value;
1402 opts->x_warn_larger_than = value != -1;
1405 case OPT_Wfatal_errors:
1406 dc->fatal_errors = value;
1409 case OPT_Wframe_larger_than_:
1410 opts->x_frame_larger_than_size = value;
1411 opts->x_warn_frame_larger_than = value != -1;
1414 case OPT_Wstrict_aliasing:
1415 set_Wstrict_aliasing (opts, value);
1418 case OPT_Wstrict_overflow:
1419 opts->x_warn_strict_overflow = (value
1420 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1424 case OPT_Wsystem_headers:
1425 dc->dc_warn_system_headers = value;
1429 opts->x_flag_gen_aux_info = 1;
1432 case OPT_auxbase_strip:
1434 char *tmp = xstrdup (arg);
1435 strip_off_ending (tmp, strlen (tmp));
1437 opts->x_aux_base_name = tmp;
1442 decode_d_option (arg, opts, loc, dc);
1445 case OPT_fcall_used_:
1446 case OPT_fcall_saved_:
1450 case OPT_fcompare_debug_second:
1451 flag_compare_debug = value;
1455 case OPT_fdbg_cnt_list:
1459 case OPT_fdebug_prefix_map_:
1463 case OPT_fdiagnostics_show_location_:
1464 diagnostic_prefixing_rule (dc) = (diagnostic_prefixing_rule_t) value;
1467 case OPT_fdiagnostics_show_option:
1468 dc->show_option_requested = value;
1475 case OPT_ffast_math:
1476 set_fast_math_flags (opts, value);
1479 case OPT_funsafe_math_optimizations:
1480 set_unsafe_math_optimizations_flags (opts, value);
1487 case OPT_finline_limit_:
1488 set_param_value ("max-inline-insns-single", value / 2,
1489 opts->x_param_values, opts_set->x_param_values);
1490 set_param_value ("max-inline-insns-auto", value / 2,
1491 opts->x_param_values, opts_set->x_param_values);
1494 case OPT_finstrument_functions_exclude_function_list_:
1495 add_comma_separated_to_vector
1496 (&opts->x_flag_instrument_functions_exclude_functions, arg);
1499 case OPT_finstrument_functions_exclude_file_list_:
1500 add_comma_separated_to_vector
1501 (&opts->x_flag_instrument_functions_exclude_files, arg);
1504 case OPT_fmessage_length_:
1505 pp_set_line_maximum_length (dc->printer, value);
1508 case OPT_fpack_struct_:
1509 if (value <= 0 || (value & (value - 1)) || value > 16)
1511 "structure alignment must be a small power of two, not %d",
1514 opts->x_initial_max_fld_align = value;
1518 case OPT_fplugin_arg_:
1522 case OPT_fprofile_use_:
1523 opts->x_profile_data_prefix = xstrdup (arg);
1524 opts->x_flag_profile_use = true;
1526 /* No break here - do -fprofile-use processing. */
1527 case OPT_fprofile_use:
1528 if (!opts_set->x_flag_branch_probabilities)
1529 opts->x_flag_branch_probabilities = value;
1530 if (!opts_set->x_flag_profile_values)
1531 opts->x_flag_profile_values = value;
1532 if (!opts_set->x_flag_unroll_loops)
1533 opts->x_flag_unroll_loops = value;
1534 if (!opts_set->x_flag_peel_loops)
1535 opts->x_flag_peel_loops = value;
1536 if (!opts_set->x_flag_tracer)
1537 opts->x_flag_tracer = value;
1538 if (!opts_set->x_flag_value_profile_transformations)
1539 opts->x_flag_value_profile_transformations = value;
1540 if (!opts_set->x_flag_inline_functions)
1541 opts->x_flag_inline_functions = value;
1542 if (!opts_set->x_flag_ipa_cp)
1543 opts->x_flag_ipa_cp = value;
1544 if (!opts_set->x_flag_ipa_cp_clone
1545 && value && opts->x_flag_ipa_cp)
1546 opts->x_flag_ipa_cp_clone = value;
1547 if (!opts_set->x_flag_predictive_commoning)
1548 opts->x_flag_predictive_commoning = value;
1549 if (!opts_set->x_flag_unswitch_loops)
1550 opts->x_flag_unswitch_loops = value;
1551 if (!opts_set->x_flag_gcse_after_reload)
1552 opts->x_flag_gcse_after_reload = value;
1555 case OPT_fprofile_generate_:
1556 opts->x_profile_data_prefix = xstrdup (arg);
1558 /* No break here - do -fprofile-generate processing. */
1559 case OPT_fprofile_generate:
1560 if (!opts_set->x_profile_arc_flag)
1561 opts->x_profile_arc_flag = value;
1562 if (!opts_set->x_flag_profile_values)
1563 opts->x_flag_profile_values = value;
1564 if (!opts_set->x_flag_value_profile_transformations)
1565 opts->x_flag_value_profile_transformations = value;
1566 if (!opts_set->x_flag_inline_functions)
1567 opts->x_flag_inline_functions = value;
1570 case OPT_fshow_column:
1571 dc->show_column = value;
1574 case OPT_frandom_seed:
1575 /* The real switch is -fno-random-seed. */
1581 case OPT_frandom_seed_:
1585 case OPT_fsched_verbose_:
1586 #ifdef INSN_SCHEDULING
1587 /* Handled with Var in common.opt. */
1593 case OPT_fsched_stalled_insns_:
1594 opts->x_flag_sched_stalled_insns = value;
1595 if (opts->x_flag_sched_stalled_insns == 0)
1596 opts->x_flag_sched_stalled_insns = -1;
1599 case OPT_fsched_stalled_insns_dep_:
1600 opts->x_flag_sched_stalled_insns_dep = value;
1603 case OPT_fstack_check_:
1604 if (!strcmp (arg, "no"))
1605 flag_stack_check = NO_STACK_CHECK;
1606 else if (!strcmp (arg, "generic"))
1607 /* This is the old stack checking method. */
1608 flag_stack_check = STACK_CHECK_BUILTIN
1609 ? FULL_BUILTIN_STACK_CHECK
1610 : GENERIC_STACK_CHECK;
1611 else if (!strcmp (arg, "specific"))
1612 /* This is the new stack checking method. */
1613 flag_stack_check = STACK_CHECK_BUILTIN
1614 ? FULL_BUILTIN_STACK_CHECK
1615 : STACK_CHECK_STATIC_BUILTIN
1616 ? STATIC_BUILTIN_STACK_CHECK
1617 : GENERIC_STACK_CHECK;
1619 warning_at (loc, 0, "unknown stack check parameter \"%s\"", arg);
1622 case OPT_fstack_limit:
1623 /* The real switch is -fno-stack-limit. */
1629 case OPT_fstack_limit_register_:
1630 case OPT_fstack_limit_symbol_:
1634 case OPT_ftree_vectorizer_verbose_:
1635 vect_set_verbosity_level (opts, value);
1639 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg, opts, opts_set,
1644 set_debug_level (SDB_DEBUG, false, arg, opts, opts_set, loc);
1648 if (value < 2 || value > 4)
1649 error_at (loc, "dwarf version %d is not supported", value);
1651 dwarf_version = value;
1652 set_debug_level (DWARF2_DEBUG, false, "", opts, opts_set, loc);
1656 set_debug_level (NO_DEBUG, 2, arg, opts, opts_set, loc);
1661 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg, opts, opts_set,
1666 set_debug_level (VMS_DEBUG, false, arg, opts, opts_set, loc);
1671 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg, opts, opts_set,
1675 case OPT_pedantic_errors:
1676 opts->x_pedantic = 1;
1677 dc->pedantic_errors = 1;
1681 opts->x_flag_lto = "";
1685 dc->dc_inhibit_warnings = true;
1688 case OPT_fmax_errors_:
1689 dc->max_errors = value;
1692 case OPT_fuse_linker_plugin:
1693 /* No-op. Used by the driver and passed to us because it starts with f.*/
1697 /* If the flag was handled in a standard way, assume the lack of
1698 processing here is intentional. */
1699 gcc_assert (option_flag_var (scode, opts));
1706 /* Handle --param NAME=VALUE. */
1708 handle_param (struct gcc_options *opts, struct gcc_options *opts_set,
1709 location_t loc, const char *carg)
1714 arg = xstrdup (carg);
1715 equal = strchr (arg, '=');
1717 error_at (loc, "%s: --param arguments should be of the form NAME=VALUE",
1721 value = integral_argument (equal + 1);
1723 error_at (loc, "invalid --param value %qs", equal + 1);
1727 set_param_value (arg, value,
1728 opts->x_param_values, opts_set->x_param_values);
1735 /* Used to set the level of strict aliasing warnings in OPTS,
1736 when no level is specified (i.e., when -Wstrict-aliasing, and not
1737 -Wstrict-aliasing=level was given).
1738 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
1739 and 0 otherwise. After calling this function, wstrict_aliasing will be
1740 set to the default value of -Wstrict_aliasing=level, currently 3. */
1742 set_Wstrict_aliasing (struct gcc_options *opts, int onoff)
1744 gcc_assert (onoff == 0 || onoff == 1);
1746 opts->x_warn_strict_aliasing = 3;
1748 opts->x_warn_strict_aliasing = 0;
1751 /* The following routines are useful in setting all the flags that
1752 -ffast-math and -fno-fast-math imply. */
1754 set_fast_math_flags (struct gcc_options *opts, int set)
1756 opts->x_flag_unsafe_math_optimizations = set;
1757 set_unsafe_math_optimizations_flags (opts, set);
1758 opts->x_flag_finite_math_only = set;
1759 opts->x_flag_errno_math = !set;
1762 opts->x_flag_signaling_nans = 0;
1763 opts->x_flag_rounding_math = 0;
1764 opts->x_flag_cx_limited_range = 1;
1768 /* When -funsafe-math-optimizations is set the following
1769 flags are set as well. */
1771 set_unsafe_math_optimizations_flags (struct gcc_options *opts, int set)
1773 opts->x_flag_trapping_math = !set;
1774 opts->x_flag_signed_zeros = !set;
1775 opts->x_flag_associative_math = set;
1776 opts->x_flag_reciprocal_math = set;
1779 /* Return true iff flags in OPTS are set as if -ffast-math. */
1781 fast_math_flags_set_p (const struct gcc_options *opts)
1783 return (!opts->x_flag_trapping_math
1784 && opts->x_flag_unsafe_math_optimizations
1785 && opts->x_flag_finite_math_only
1786 && !opts->x_flag_signed_zeros
1787 && !opts->x_flag_errno_math);
1790 /* Return true iff flags are set as if -ffast-math but using the flags stored
1791 in the struct cl_optimization structure. */
1793 fast_math_flags_struct_set_p (struct cl_optimization *opt)
1795 return (!opt->x_flag_trapping_math
1796 && opt->x_flag_unsafe_math_optimizations
1797 && opt->x_flag_finite_math_only
1798 && !opt->x_flag_signed_zeros
1799 && !opt->x_flag_errno_math);
1802 /* Handle a debug output -g switch for options OPTS
1803 (OPTS_SET->x_write_symbols storing whether a debug type was passed
1804 explicitly), location LOC. EXTENDED is true or false to support
1805 extended output (2 is special and means "-ggdb" was given). */
1807 set_debug_level (enum debug_info_type type, int extended, const char *arg,
1808 struct gcc_options *opts, struct gcc_options *opts_set,
1811 opts->x_use_gnu_debug_info_extensions = extended;
1813 if (type == NO_DEBUG)
1815 if (opts->x_write_symbols == NO_DEBUG)
1817 opts->x_write_symbols = PREFERRED_DEBUGGING_TYPE;
1821 #ifdef DWARF2_DEBUGGING_INFO
1822 opts->x_write_symbols = DWARF2_DEBUG;
1823 #elif defined DBX_DEBUGGING_INFO
1824 opts->x_write_symbols = DBX_DEBUG;
1828 if (opts->x_write_symbols == NO_DEBUG)
1829 warning_at (loc, 0, "target system does not support debug output");
1834 /* Does it conflict with an already selected type? */
1835 if (opts_set->x_write_symbols != NO_DEBUG
1836 && opts->x_write_symbols != NO_DEBUG
1837 && type != opts->x_write_symbols)
1838 error_at (loc, "debug format \"%s\" conflicts with prior selection",
1839 debug_type_names[type]);
1840 opts->x_write_symbols = type;
1841 opts_set->x_write_symbols = type;
1844 /* A debug flag without a level defaults to level 2. */
1847 if (!opts->x_debug_info_level)
1848 opts->x_debug_info_level = DINFO_LEVEL_NORMAL;
1852 int argval = integral_argument (arg);
1854 error_at (loc, "unrecognised debug output level \"%s\"", arg);
1855 else if (argval > 3)
1856 error_at (loc, "debug output level %s is too high", arg);
1858 opts->x_debug_info_level = (enum debug_info_levels) argval;
1862 /* Arrange to dump core on error for diagnostic context DC. (The
1863 regular error message is still printed first, except in the case of
1867 setup_core_dumping (diagnostic_context *dc)
1870 signal (SIGABRT, SIG_DFL);
1872 #if defined(HAVE_SETRLIMIT)
1875 if (getrlimit (RLIMIT_CORE, &rlim) != 0)
1876 fatal_error ("getting core file size maximum limit: %m");
1877 rlim.rlim_cur = rlim.rlim_max;
1878 if (setrlimit (RLIMIT_CORE, &rlim) != 0)
1879 fatal_error ("setting core file size limit to maximum: %m");
1882 diagnostic_abort_on_error (dc);
1885 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
1886 diagnostic context DC. */
1889 decode_d_option (const char *arg, struct gcc_options *opts,
1890 location_t loc, diagnostic_context *dc)
1898 opts->x_flag_debug_asm = 1;
1901 opts->x_flag_print_asm_name = 1;
1904 opts->x_flag_dump_rtl_in_asm = 1;
1905 opts->x_flag_print_asm_name = 1;
1908 opts->x_graph_dump_format = vcg;
1911 opts->x_rtl_dump_and_exit = 1;
1913 case 'D': /* These are handled by the preprocessor. */
1920 setup_core_dumping (dc);
1923 opts->x_flag_dump_all_passed = true;
1927 warning_at (loc, 0, "unrecognized gcc debugging option: %c", c);
1932 /* Enable (or disable if VALUE is 0) a warning option ARG (language
1933 mask LANG_MASK, option handlers HANDLERS) as an error for option
1934 structures OPTS and OPTS_SET, diagnostic context DC (possibly
1935 NULL), location LOC. This is used by -Werror=. */
1938 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
1939 const struct cl_option_handlers *handlers,
1940 struct gcc_options *opts,
1941 struct gcc_options *opts_set,
1942 location_t loc, diagnostic_context *dc)
1947 new_option = XNEWVEC (char, strlen (arg) + 2);
1948 new_option[0] = 'W';
1949 strcpy (new_option + 1, arg);
1950 option_index = find_opt (new_option, lang_mask);
1951 if (option_index == OPT_SPECIAL_unknown)
1953 error_at (loc, "-Werror=%s: no option -%s", arg, new_option);
1957 const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
1959 control_warning_option (option_index, (int) kind, value,
1961 handlers, opts, opts_set, dc);
1966 /* Return malloced memory for the name of the option OPTION_INDEX
1967 which enabled a diagnostic (context CONTEXT), originally of type
1968 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
1972 option_name (diagnostic_context *context, int option_index,
1973 diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
1977 /* A warning classified as an error. */
1978 if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
1979 && diag_kind == DK_ERROR)
1980 return concat (cl_options[OPT_Werror_].opt_text,
1981 /* Skip over "-W". */
1982 cl_options[option_index].opt_text + 2,
1984 /* A warning with option. */
1986 return xstrdup (cl_options[option_index].opt_text);
1988 /* A warning without option classified as an error. */
1989 else if (orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
1990 || diag_kind == DK_WARNING)
1992 if (context->warning_as_error_requested)
1993 return xstrdup (cl_options[OPT_Werror].opt_text);
1995 return xstrdup (_("enabled by default"));