1 /* Command line option handling.
2 Copyright (C) 2002-2020 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
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
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/>. */
24 #include "coretypes.h"
28 #include "diagnostic.h"
29 #include "opts-diagnostic.h"
30 #include "insn-attr-common.h"
31 #include "common/common-target.h"
32 #include "spellcheck.h"
33 #include "opt-suggestions.h"
34 #include "diagnostic-color.h"
37 static void set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
);
39 /* Indexed by enum debug_info_type. */
40 const char *const debug_type_names
[] =
42 "none", "stabs", "dwarf-2", "xcoff", "vms"
45 /* Parse the -femit-struct-debug-detailed option value
46 and set the flag variables. */
48 #define MATCH( prefix, string ) \
49 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
50 ? ((string += sizeof prefix - 1), 1) : 0)
53 set_struct_debug_option (struct gcc_options
*opts
, location_t loc
,
56 /* various labels for comparison */
57 static const char dfn_lbl
[] = "dfn:", dir_lbl
[] = "dir:", ind_lbl
[] = "ind:";
58 static const char ord_lbl
[] = "ord:", gen_lbl
[] = "gen:";
59 static const char none_lbl
[] = "none", any_lbl
[] = "any";
60 static const char base_lbl
[] = "base", sys_lbl
[] = "sys";
62 enum debug_struct_file files
= DINFO_STRUCT_FILE_ANY
;
63 /* Default is to apply to as much as possible. */
64 enum debug_info_usage usage
= DINFO_USAGE_NUM_ENUMS
;
68 if (MATCH (dfn_lbl
, spec
))
69 usage
= DINFO_USAGE_DFN
;
70 else if (MATCH (dir_lbl
, spec
))
71 usage
= DINFO_USAGE_DIR_USE
;
72 else if (MATCH (ind_lbl
, spec
))
73 usage
= DINFO_USAGE_IND_USE
;
75 /* Generics or not? */
76 if (MATCH (ord_lbl
, spec
))
78 else if (MATCH (gen_lbl
, spec
))
81 /* What allowable environment? */
82 if (MATCH (none_lbl
, spec
))
83 files
= DINFO_STRUCT_FILE_NONE
;
84 else if (MATCH (any_lbl
, spec
))
85 files
= DINFO_STRUCT_FILE_ANY
;
86 else if (MATCH (sys_lbl
, spec
))
87 files
= DINFO_STRUCT_FILE_SYS
;
88 else if (MATCH (base_lbl
, spec
))
89 files
= DINFO_STRUCT_FILE_BASE
;
92 "argument %qs to %<-femit-struct-debug-detailed%> "
96 /* Effect the specification. */
97 if (usage
== DINFO_USAGE_NUM_ENUMS
)
101 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DFN
] = files
;
102 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
] = files
;
103 opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
] = files
;
107 opts
->x_debug_struct_generic
[DINFO_USAGE_DFN
] = files
;
108 opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
] = files
;
109 opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
] = files
;
115 opts
->x_debug_struct_ordinary
[usage
] = files
;
117 opts
->x_debug_struct_generic
[usage
] = files
;
121 set_struct_debug_option (opts
, loc
, spec
+1);
124 /* No more -femit-struct-debug-detailed specifications.
128 "argument %qs to %<-femit-struct-debug-detailed%> unknown",
130 if (opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
]
131 < opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
]
132 || opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
]
133 < opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
])
135 "%<-femit-struct-debug-detailed=dir:...%> must allow "
136 "at least as much as "
137 "%<-femit-struct-debug-detailed=ind:...%>");
141 /* Strip off a legitimate source ending from the input string NAME of
142 length LEN. Rather than having to know the names used by all of
143 our front ends, we strip off an ending of a period followed by
144 up to fource characters. (C++ uses ".cpp".) */
147 strip_off_ending (char *name
, int len
)
150 for (i
= 2; i
< 5 && len
> i
; i
++)
152 if (name
[len
- i
] == '.')
154 name
[len
- i
] = '\0';
160 /* Find the base name of a path, stripping off both directories and
161 a single final extension. */
163 base_of_path (const char *path
, const char **base_out
)
165 const char *base
= path
;
167 const char *p
= path
;
171 if (IS_DIR_SEPARATOR (c
))
186 /* What to print when a switch has no documentation. */
187 static const char undocumented_msg
[] = N_("This option lacks documentation.");
188 static const char use_diagnosed_msg
[] = N_("Uses of this option are diagnosed.");
190 typedef char *char_p
; /* For DEF_VEC_P. */
192 static void set_debug_level (enum debug_info_type type
, int extended
,
193 const char *arg
, struct gcc_options
*opts
,
194 struct gcc_options
*opts_set
,
196 static void set_fast_math_flags (struct gcc_options
*opts
, int set
);
197 static void decode_d_option (const char *arg
, struct gcc_options
*opts
,
198 location_t loc
, diagnostic_context
*dc
);
199 static void set_unsafe_math_optimizations_flags (struct gcc_options
*opts
,
201 static void enable_warning_as_error (const char *arg
, int value
,
202 unsigned int lang_mask
,
203 const struct cl_option_handlers
*handlers
,
204 struct gcc_options
*opts
,
205 struct gcc_options
*opts_set
,
207 diagnostic_context
*dc
);
209 /* Handle a back-end option; arguments and return value as for
213 target_handle_option (struct gcc_options
*opts
,
214 struct gcc_options
*opts_set
,
215 const struct cl_decoded_option
*decoded
,
216 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
218 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
219 diagnostic_context
*dc
, void (*) (void))
221 gcc_assert (dc
== global_dc
);
222 gcc_assert (kind
== DK_UNSPECIFIED
);
223 return targetm_common
.handle_option (opts
, opts_set
, decoded
, loc
);
226 /* Add comma-separated strings to a char_p vector. */
229 add_comma_separated_to_vector (void **pvec
, const char *arg
)
235 vec
<char_p
> *v
= (vec
<char_p
> *) *pvec
;
237 vec_check_alloc (v
, 1);
239 /* We never free this string. */
252 v
->safe_push (token_start
);
255 if (*r
== '\\' && r
[1] == ',')
265 if (*token_start
!= '\0')
266 v
->safe_push (token_start
);
271 /* Initialize opts_obstack. */
274 init_opts_obstack (void)
276 gcc_obstack_init (&opts_obstack
);
279 /* Initialize OPTS and OPTS_SET before using them in parsing options. */
282 init_options_struct (struct gcc_options
*opts
, struct gcc_options
*opts_set
)
284 /* Ensure that opts_obstack has already been initialized by the time
285 that we initialize any gcc_options instances (PR jit/68446). */
286 gcc_assert (opts_obstack
.chunk_size
> 0);
288 *opts
= global_options_init
;
291 memset (opts_set
, 0, sizeof (*opts_set
));
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. */
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
,
323 diagnostic_context
*dc
)
325 const struct cl_option
*option
= &cl_options
[default_opt
->opt_index
];
329 gcc_assert (level
== 2);
331 gcc_assert (level
== 3);
333 gcc_assert (level
== 1);
335 switch (default_opt
->levels
)
341 case OPT_LEVELS_0_ONLY
:
342 enabled
= (level
== 0);
345 case OPT_LEVELS_1_PLUS
:
346 enabled
= (level
>= 1);
349 case OPT_LEVELS_1_PLUS_SPEED_ONLY
:
350 enabled
= (level
>= 1 && !size
&& !debug
);
353 case OPT_LEVELS_1_PLUS_NOT_DEBUG
:
354 enabled
= (level
>= 1 && !debug
);
357 case OPT_LEVELS_2_PLUS
:
358 enabled
= (level
>= 2);
361 case OPT_LEVELS_2_PLUS_SPEED_ONLY
:
362 enabled
= (level
>= 2 && !size
&& !debug
);
365 case OPT_LEVELS_3_PLUS
:
366 enabled
= (level
>= 3);
369 case OPT_LEVELS_3_PLUS_AND_SIZE
:
370 enabled
= (level
>= 3 || size
);
373 case OPT_LEVELS_SIZE
:
377 case OPT_LEVELS_FAST
:
381 case OPT_LEVELS_NONE
:
387 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
388 default_opt
->arg
, default_opt
->value
,
389 lang_mask
, DK_UNSPECIFIED
, loc
,
391 else if (default_opt
->arg
== NULL
392 && !option
->cl_reject_negative
393 && !(option
->flags
& CL_PARAMS
))
394 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
395 default_opt
->arg
, !default_opt
->value
,
396 lang_mask
, DK_UNSPECIFIED
, loc
,
400 /* As indicated by the optimization level LEVEL (-Os if SIZE is set,
401 -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
402 OPTS and OPTS_SET, diagnostic context DC, location LOC, with
403 language mask LANG_MASK and option handlers HANDLERS. */
406 maybe_default_options (struct gcc_options
*opts
,
407 struct gcc_options
*opts_set
,
408 const struct default_options
*default_opts
,
409 int level
, bool size
, bool fast
, bool debug
,
410 unsigned int lang_mask
,
411 const struct cl_option_handlers
*handlers
,
413 diagnostic_context
*dc
)
417 for (i
= 0; default_opts
[i
].levels
!= OPT_LEVELS_NONE
; i
++)
418 maybe_default_option (opts
, opts_set
, &default_opts
[i
],
419 level
, size
, fast
, debug
,
420 lang_mask
, handlers
, loc
, dc
);
423 /* Table of options enabled by default at different levels.
424 Please keep this list sorted by level and alphabetized within
425 each level; this makes it easier to keep the documentation
428 static const struct default_options default_options_table
[] =
430 /* -O1 and -Og optimizations. */
431 { OPT_LEVELS_1_PLUS
, OPT_fcombine_stack_adjustments
, NULL
, 1 },
432 { OPT_LEVELS_1_PLUS
, OPT_fcompare_elim
, NULL
, 1 },
433 { OPT_LEVELS_1_PLUS
, OPT_fcprop_registers
, NULL
, 1 },
434 { OPT_LEVELS_1_PLUS
, OPT_fdefer_pop
, NULL
, 1 },
435 { OPT_LEVELS_1_PLUS
, OPT_fforward_propagate
, NULL
, 1 },
436 { OPT_LEVELS_1_PLUS
, OPT_fguess_branch_probability
, NULL
, 1 },
437 { OPT_LEVELS_1_PLUS
, OPT_fipa_profile
, NULL
, 1 },
438 { OPT_LEVELS_1_PLUS
, OPT_fipa_pure_const
, NULL
, 1 },
439 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference
, NULL
, 1 },
440 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference_addressable
, NULL
, 1 },
441 { OPT_LEVELS_1_PLUS
, OPT_fmerge_constants
, NULL
, 1 },
442 { OPT_LEVELS_1_PLUS
, OPT_fomit_frame_pointer
, NULL
, 1 },
443 { OPT_LEVELS_1_PLUS
, OPT_freorder_blocks
, NULL
, 1 },
444 { OPT_LEVELS_1_PLUS
, OPT_fshrink_wrap
, NULL
, 1 },
445 { OPT_LEVELS_1_PLUS
, OPT_fsplit_wide_types
, NULL
, 1 },
446 { OPT_LEVELS_1_PLUS
, OPT_ftree_builtin_call_dce
, NULL
, 1 },
447 { OPT_LEVELS_1_PLUS
, OPT_ftree_ccp
, NULL
, 1 },
448 { OPT_LEVELS_1_PLUS
, OPT_ftree_ch
, NULL
, 1 },
449 { OPT_LEVELS_1_PLUS
, OPT_ftree_coalesce_vars
, NULL
, 1 },
450 { OPT_LEVELS_1_PLUS
, OPT_ftree_copy_prop
, NULL
, 1 },
451 { OPT_LEVELS_1_PLUS
, OPT_ftree_dce
, NULL
, 1 },
452 { OPT_LEVELS_1_PLUS
, OPT_ftree_dominator_opts
, NULL
, 1 },
453 { OPT_LEVELS_1_PLUS
, OPT_ftree_fre
, NULL
, 1 },
454 { OPT_LEVELS_1_PLUS
, OPT_ftree_sink
, NULL
, 1 },
455 { OPT_LEVELS_1_PLUS
, OPT_ftree_slsr
, NULL
, 1 },
456 { OPT_LEVELS_1_PLUS
, OPT_ftree_ter
, NULL
, 1 },
458 /* -O1 (and not -Og) optimizations. */
459 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fbranch_count_reg
, NULL
, 1 },
461 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fdelayed_branch
, NULL
, 1 },
463 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fdse
, NULL
, 1 },
464 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion
, NULL
, 1 },
465 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion2
, NULL
, 1 },
466 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_finline_functions_called_once
, NULL
, 1 },
467 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_invariants
, NULL
, 1 },
468 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fssa_phiopt
, NULL
, 1 },
469 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fipa_modref
, NULL
, 1 },
470 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_bit_ccp
, NULL
, 1 },
471 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_dse
, NULL
, 1 },
472 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_pta
, NULL
, 1 },
473 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_sra
, NULL
, 1 },
475 /* -O2 and -Os optimizations. */
476 { OPT_LEVELS_2_PLUS
, OPT_fcaller_saves
, NULL
, 1 },
477 { OPT_LEVELS_2_PLUS
, OPT_fcode_hoisting
, NULL
, 1 },
478 { OPT_LEVELS_2_PLUS
, OPT_fcrossjumping
, NULL
, 1 },
479 { OPT_LEVELS_2_PLUS
, OPT_fcse_follow_jumps
, NULL
, 1 },
480 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize
, NULL
, 1 },
481 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize_speculatively
, NULL
, 1 },
482 { OPT_LEVELS_2_PLUS
, OPT_fexpensive_optimizations
, NULL
, 1 },
483 { OPT_LEVELS_2_PLUS
, OPT_fgcse
, NULL
, 1 },
484 { OPT_LEVELS_2_PLUS
, OPT_fhoist_adjacent_loads
, NULL
, 1 },
485 { OPT_LEVELS_2_PLUS
, OPT_findirect_inlining
, NULL
, 1 },
486 { OPT_LEVELS_2_PLUS
, OPT_finline_small_functions
, NULL
, 1 },
487 { OPT_LEVELS_2_PLUS
, OPT_fipa_bit_cp
, NULL
, 1 },
488 { OPT_LEVELS_2_PLUS
, OPT_fipa_cp
, NULL
, 1 },
489 { OPT_LEVELS_2_PLUS
, OPT_fipa_icf
, NULL
, 1 },
490 { OPT_LEVELS_2_PLUS
, OPT_fipa_ra
, NULL
, 1 },
491 { OPT_LEVELS_2_PLUS
, OPT_fipa_sra
, NULL
, 1 },
492 { OPT_LEVELS_2_PLUS
, OPT_fipa_vrp
, NULL
, 1 },
493 { OPT_LEVELS_2_PLUS
, OPT_fisolate_erroneous_paths_dereference
, NULL
, 1 },
494 { OPT_LEVELS_2_PLUS
, OPT_flra_remat
, NULL
, 1 },
495 { OPT_LEVELS_2_PLUS
, OPT_foptimize_sibling_calls
, NULL
, 1 },
496 { OPT_LEVELS_2_PLUS
, OPT_fpartial_inlining
, NULL
, 1 },
497 { OPT_LEVELS_2_PLUS
, OPT_fpeephole2
, NULL
, 1 },
498 { OPT_LEVELS_2_PLUS
, OPT_freorder_functions
, NULL
, 1 },
499 { OPT_LEVELS_2_PLUS
, OPT_frerun_cse_after_loop
, NULL
, 1 },
500 #ifdef INSN_SCHEDULING
501 { OPT_LEVELS_2_PLUS
, OPT_fschedule_insns2
, NULL
, 1 },
503 { OPT_LEVELS_2_PLUS
, OPT_fstrict_aliasing
, NULL
, 1 },
504 { OPT_LEVELS_2_PLUS
, OPT_fstore_merging
, NULL
, 1 },
505 { OPT_LEVELS_2_PLUS
, OPT_fthread_jumps
, NULL
, 1 },
506 { OPT_LEVELS_2_PLUS
, OPT_ftree_pre
, NULL
, 1 },
507 { OPT_LEVELS_2_PLUS
, OPT_ftree_switch_conversion
, NULL
, 1 },
508 { OPT_LEVELS_2_PLUS
, OPT_ftree_tail_merge
, NULL
, 1 },
509 { OPT_LEVELS_2_PLUS
, OPT_ftree_vrp
, NULL
, 1 },
510 { OPT_LEVELS_2_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_CHEAP
},
511 { OPT_LEVELS_2_PLUS
, OPT_finline_functions
, NULL
, 1 },
512 { OPT_LEVELS_2_PLUS
, OPT_ftree_loop_distribute_patterns
, NULL
, 1 },
514 /* -O2 and above optimizations, but not -Os or -Og. */
515 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_functions
, NULL
, 1 },
516 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_jumps
, NULL
, 1 },
517 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_labels
, NULL
, 1 },
518 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_loops
, NULL
, 1 },
519 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_foptimize_strlen
, NULL
, 1 },
520 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_freorder_blocks_algorithm_
, NULL
,
521 REORDER_BLOCKS_ALGORITHM_STC
},
522 #ifdef INSN_SCHEDULING
523 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
524 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_fschedule_insns
, NULL
, 1 },
527 /* -O3 and -Os optimizations. */
529 /* -O3 optimizations. */
530 { OPT_LEVELS_3_PLUS
, OPT_fgcse_after_reload
, NULL
, 1 },
531 { OPT_LEVELS_3_PLUS
, OPT_fipa_cp_clone
, NULL
, 1 },
532 { OPT_LEVELS_3_PLUS
, OPT_floop_interchange
, NULL
, 1 },
533 { OPT_LEVELS_3_PLUS
, OPT_floop_unroll_and_jam
, NULL
, 1 },
534 { OPT_LEVELS_3_PLUS
, OPT_fpeel_loops
, NULL
, 1 },
535 { OPT_LEVELS_3_PLUS
, OPT_fpredictive_commoning
, NULL
, 1 },
536 { OPT_LEVELS_3_PLUS
, OPT_fsplit_loops
, NULL
, 1 },
537 { OPT_LEVELS_3_PLUS
, OPT_fsplit_paths
, NULL
, 1 },
538 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribution
, NULL
, 1 },
539 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_vectorize
, NULL
, 1 },
540 { OPT_LEVELS_3_PLUS
, OPT_ftree_partial_pre
, NULL
, 1 },
541 { OPT_LEVELS_3_PLUS
, OPT_ftree_slp_vectorize
, NULL
, 1 },
542 { OPT_LEVELS_3_PLUS
, OPT_funswitch_loops
, NULL
, 1 },
543 { OPT_LEVELS_3_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_DYNAMIC
},
544 { OPT_LEVELS_3_PLUS
, OPT_fversion_loops_for_strides
, NULL
, 1 },
546 /* -O3 parameters. */
547 { OPT_LEVELS_3_PLUS
, OPT__param_max_inline_insns_auto_
, NULL
, 30 },
548 { OPT_LEVELS_3_PLUS
, OPT__param_early_inlining_insns_
, NULL
, 14 },
549 { OPT_LEVELS_3_PLUS
, OPT__param_inline_heuristics_hint_percent_
, NULL
, 600 },
550 { OPT_LEVELS_3_PLUS
, OPT__param_inline_min_speedup_
, NULL
, 15 },
551 { OPT_LEVELS_3_PLUS
, OPT__param_max_inline_insns_single_
, NULL
, 200 },
553 /* -Ofast adds optimizations to -O3. */
554 { OPT_LEVELS_FAST
, OPT_ffast_math
, NULL
, 1 },
555 { OPT_LEVELS_FAST
, OPT_fallow_store_data_races
, NULL
, 1 },
557 { OPT_LEVELS_NONE
, 0, NULL
, 0 }
560 /* Default the options in OPTS and OPTS_SET based on the optimization
561 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
563 default_options_optimization (struct gcc_options
*opts
,
564 struct gcc_options
*opts_set
,
565 struct cl_decoded_option
*decoded_options
,
566 unsigned int decoded_options_count
,
568 unsigned int lang_mask
,
569 const struct cl_option_handlers
*handlers
,
570 diagnostic_context
*dc
)
574 bool openacc_mode
= false;
576 /* Scan to see what optimization level has been specified. That will
577 determine the default value of many flags. */
578 for (i
= 1; i
< decoded_options_count
; i
++)
580 struct cl_decoded_option
*opt
= &decoded_options
[i
];
581 switch (opt
->opt_index
)
584 if (*opt
->arg
== '\0')
586 opts
->x_optimize
= 1;
587 opts
->x_optimize_size
= 0;
588 opts
->x_optimize_fast
= 0;
589 opts
->x_optimize_debug
= 0;
593 const int optimize_val
= integral_argument (opt
->arg
);
594 if (optimize_val
== -1)
595 error_at (loc
, "argument to %<-O%> should be a non-negative "
596 "integer, %<g%>, %<s%> or %<fast%>");
599 opts
->x_optimize
= optimize_val
;
600 if ((unsigned int) opts
->x_optimize
> 255)
601 opts
->x_optimize
= 255;
602 opts
->x_optimize_size
= 0;
603 opts
->x_optimize_fast
= 0;
604 opts
->x_optimize_debug
= 0;
610 opts
->x_optimize_size
= 1;
612 /* Optimizing for size forces optimize to be 2. */
613 opts
->x_optimize
= 2;
614 opts
->x_optimize_fast
= 0;
615 opts
->x_optimize_debug
= 0;
619 /* -Ofast only adds flags to -O3. */
620 opts
->x_optimize_size
= 0;
621 opts
->x_optimize
= 3;
622 opts
->x_optimize_fast
= 1;
623 opts
->x_optimize_debug
= 0;
627 /* -Og selects optimization level 1. */
628 opts
->x_optimize_size
= 0;
629 opts
->x_optimize
= 1;
630 opts
->x_optimize_fast
= 0;
631 opts
->x_optimize_debug
= 1;
640 /* Ignore other options in this prescan. */
645 maybe_default_options (opts
, opts_set
, default_options_table
,
646 opts
->x_optimize
, opts
->x_optimize_size
,
647 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
648 lang_mask
, handlers
, loc
, dc
);
650 /* -O2 param settings. */
651 opt2
= (opts
->x_optimize
>= 2);
654 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_pta
, true);
656 /* Track fields in field-sensitive alias analysis. */
658 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_fields_for_field_sensitive
,
661 if (opts
->x_optimize_size
)
662 /* We want to crossjump as much as possible. */
663 SET_OPTION_IF_UNSET (opts
, opts_set
, param_min_crossjump_insns
, 1);
665 /* Restrict the amount of work combine does at -Og while retaining
666 most of its useful transforms. */
667 if (opts
->x_optimize_debug
)
668 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_combine_insns
, 2);
670 /* Allow default optimizations to be specified on a per-machine basis. */
671 maybe_default_options (opts
, opts_set
,
672 targetm_common
.option_optimization_table
,
673 opts
->x_optimize
, opts
->x_optimize_size
,
674 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
675 lang_mask
, handlers
, loc
, dc
);
678 /* Control IPA optimizations based on different live patching LEVEL. */
680 control_options_for_live_patching (struct gcc_options
*opts
,
681 struct gcc_options
*opts_set
,
682 enum live_patching_level level
,
685 gcc_assert (level
> LIVE_PATCHING_NONE
);
689 case LIVE_PATCHING_INLINE_ONLY_STATIC
:
690 if (opts_set
->x_flag_ipa_cp_clone
&& opts
->x_flag_ipa_cp_clone
)
691 error_at (loc
, "%qs is incompatible with %qs",
692 "-fipa-cp-clone", "-flive-patching=inline-only-static");
694 opts
->x_flag_ipa_cp_clone
= 0;
696 if (opts_set
->x_flag_ipa_sra
&& opts
->x_flag_ipa_sra
)
697 error_at (loc
, "%qs is incompatible with %qs",
698 "-fipa-sra", "-flive-patching=inline-only-static");
700 opts
->x_flag_ipa_sra
= 0;
702 if (opts_set
->x_flag_partial_inlining
&& opts
->x_flag_partial_inlining
)
703 error_at (loc
, "%qs is incompatible with %qs",
704 "-fpartial-inlining", "-flive-patching=inline-only-static");
706 opts
->x_flag_partial_inlining
= 0;
708 if (opts_set
->x_flag_ipa_cp
&& opts
->x_flag_ipa_cp
)
709 error_at (loc
, "%qs is incompatible with %qs",
710 "-fipa-cp", "-flive-patching=inline-only-static");
712 opts
->x_flag_ipa_cp
= 0;
715 case LIVE_PATCHING_INLINE_CLONE
:
716 /* live patching should disable whole-program optimization. */
717 if (opts_set
->x_flag_whole_program
&& opts
->x_flag_whole_program
)
718 error_at (loc
, "%qs is incompatible with %qs",
720 "-flive-patching=inline-only-static|inline-clone");
722 opts
->x_flag_whole_program
= 0;
724 /* visibility change should be excluded by !flag_whole_program
725 && !in_lto_p && !flag_ipa_cp_clone && !flag_ipa_sra
726 && !flag_partial_inlining. */
728 if (opts_set
->x_flag_ipa_pta
&& opts
->x_flag_ipa_pta
)
729 error_at (loc
, "%qs is incompatible with %qs",
731 "-flive-patching=inline-only-static|inline-clone");
733 opts
->x_flag_ipa_pta
= 0;
735 if (opts_set
->x_flag_ipa_reference
&& opts
->x_flag_ipa_reference
)
736 error_at (loc
, "%qs is incompatible with %qs",
738 "-flive-patching=inline-only-static|inline-clone");
740 opts
->x_flag_ipa_reference
= 0;
742 if (opts_set
->x_flag_ipa_ra
&& opts
->x_flag_ipa_ra
)
743 error_at (loc
, "%qs is incompatible with %qs",
745 "-flive-patching=inline-only-static|inline-clone");
747 opts
->x_flag_ipa_ra
= 0;
749 if (opts_set
->x_flag_ipa_icf
&& opts
->x_flag_ipa_icf
)
750 error_at (loc
, "%qs is incompatible with %qs",
752 "-flive-patching=inline-only-static|inline-clone");
754 opts
->x_flag_ipa_icf
= 0;
756 if (opts_set
->x_flag_ipa_icf_functions
&& opts
->x_flag_ipa_icf_functions
)
757 error_at (loc
, "%qs is incompatible with %qs",
758 "-fipa-icf-functions",
759 "-flive-patching=inline-only-static|inline-clone");
761 opts
->x_flag_ipa_icf_functions
= 0;
763 if (opts_set
->x_flag_ipa_icf_variables
&& opts
->x_flag_ipa_icf_variables
)
764 error_at (loc
, "%qs is incompatible with %qs",
765 "-fipa-icf-variables",
766 "-flive-patching=inline-only-static|inline-clone");
768 opts
->x_flag_ipa_icf_variables
= 0;
770 if (opts_set
->x_flag_ipa_bit_cp
&& opts
->x_flag_ipa_bit_cp
)
771 error_at (loc
, "%qs is incompatible with %qs",
773 "-flive-patching=inline-only-static|inline-clone");
775 opts
->x_flag_ipa_bit_cp
= 0;
777 if (opts_set
->x_flag_ipa_vrp
&& opts
->x_flag_ipa_vrp
)
778 error_at (loc
, "%qs is incompatible with %qs",
780 "-flive-patching=inline-only-static|inline-clone");
782 opts
->x_flag_ipa_vrp
= 0;
784 if (opts_set
->x_flag_ipa_pure_const
&& opts
->x_flag_ipa_pure_const
)
785 error_at (loc
, "%qs is incompatible with %qs",
787 "-flive-patching=inline-only-static|inline-clone");
789 opts
->x_flag_ipa_pure_const
= 0;
791 if (opts_set
->x_flag_ipa_modref
&& opts
->x_flag_ipa_modref
)
793 "%<-fipa-modref%> is incompatible with "
794 "%<-flive-patching=inline-only-static|inline-clone%>");
796 opts
->x_flag_ipa_modref
= 0;
798 /* FIXME: disable unreachable code removal. */
800 /* discovery of functions/variables with no address taken. */
801 if (opts_set
->x_flag_ipa_reference_addressable
802 && opts
->x_flag_ipa_reference_addressable
)
803 error_at (loc
, "%qs is incompatible with %qs",
804 "-fipa-reference-addressable",
805 "-flive-patching=inline-only-static|inline-clone");
807 opts
->x_flag_ipa_reference_addressable
= 0;
809 /* ipa stack alignment propagation. */
810 if (opts_set
->x_flag_ipa_stack_alignment
811 && opts
->x_flag_ipa_stack_alignment
)
812 error_at (loc
, "%qs is incompatible with %qs",
813 "-fipa-stack-alignment",
814 "-flive-patching=inline-only-static|inline-clone");
816 opts
->x_flag_ipa_stack_alignment
= 0;
823 /* --help option argument if set. */
824 vec
<const char *> help_option_arguments
;
827 /* After all options at LOC have been read into OPTS and OPTS_SET,
828 finalize settings of those options and diagnose incompatible
831 finish_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
834 enum unwind_info_type ui_except
;
836 if (opts
->x_dump_base_name
837 && ! opts
->x_dump_base_name_prefixed
)
839 const char *sep
= opts
->x_dump_base_name
;
842 if (IS_DIR_SEPARATOR (*sep
))
846 /* If dump_base_path contains subdirectories, don't prepend
848 else if (opts
->x_dump_dir_name
)
849 /* We have a DUMP_DIR_NAME, prepend that. */
850 opts
->x_dump_base_name
= opts_concat (opts
->x_dump_dir_name
,
851 opts
->x_dump_base_name
, NULL
);
853 /* It is definitely prefixed now. */
854 opts
->x_dump_base_name_prefixed
= true;
857 /* Handle related options for unit-at-a-time, toplevel-reorder, and
859 if (!opts
->x_flag_unit_at_a_time
)
861 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
862 error_at (loc
, "section anchors must be disabled when unit-at-a-time "
864 opts
->x_flag_section_anchors
= 0;
865 if (opts
->x_flag_toplevel_reorder
== 1)
866 error_at (loc
, "toplevel reorder must be disabled when unit-at-a-time "
868 opts
->x_flag_toplevel_reorder
= 0;
871 /* -fself-test depends on the state of the compiler prior to
872 compiling anything. Ideally it should be run on an empty source
873 file. However, in case we get run with actual source, assume
874 -fsyntax-only which will inhibit any compiler initialization
875 which may confuse the self tests. */
876 if (opts
->x_flag_self_test
)
877 opts
->x_flag_syntax_only
= 1;
879 if (opts
->x_flag_tm
&& opts
->x_flag_non_call_exceptions
)
880 sorry ("transactional memory is not supported with non-call exceptions");
882 /* Unless the user has asked for section anchors, we disable toplevel
883 reordering at -O0 to disable transformations that might be surprising
884 to end users and to get -fno-toplevel-reorder tested. */
885 if (!opts
->x_optimize
886 && opts
->x_flag_toplevel_reorder
== 2
887 && !(opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
))
889 opts
->x_flag_toplevel_reorder
= 0;
890 opts
->x_flag_section_anchors
= 0;
892 if (!opts
->x_flag_toplevel_reorder
)
894 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
895 error_at (loc
, "section anchors must be disabled when toplevel reorder"
897 opts
->x_flag_section_anchors
= 0;
900 if (!opts
->x_flag_opts_finished
)
902 /* We initialize opts->x_flag_pie to -1 so that targets can set a
904 if (opts
->x_flag_pie
== -1)
906 /* We initialize opts->x_flag_pic to -1 so that we can tell if
907 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
908 if (opts
->x_flag_pic
== -1)
909 opts
->x_flag_pie
= DEFAULT_FLAG_PIE
;
911 opts
->x_flag_pie
= 0;
913 /* If -fPIE or -fpie is used, turn on PIC. */
914 if (opts
->x_flag_pie
)
915 opts
->x_flag_pic
= opts
->x_flag_pie
;
916 else if (opts
->x_flag_pic
== -1)
917 opts
->x_flag_pic
= 0;
918 if (opts
->x_flag_pic
&& !opts
->x_flag_pie
)
919 opts
->x_flag_shlib
= 1;
920 opts
->x_flag_opts_finished
= true;
923 /* We initialize opts->x_flag_stack_protect to -1 so that targets
924 can set a default value. */
925 if (opts
->x_flag_stack_protect
== -1)
926 opts
->x_flag_stack_protect
= DEFAULT_FLAG_SSP
;
928 if (opts
->x_optimize
== 0)
930 /* Inlining does not work if not optimizing,
931 so force it not to be done. */
932 opts
->x_warn_inline
= 0;
933 opts
->x_flag_no_inline
= 1;
936 /* The optimization to partition hot and cold basic blocks into separate
937 sections of the .o and executable files does not work (currently)
938 with exception handling. This is because there is no support for
939 generating unwind info. If opts->x_flag_exceptions is turned on
940 we need to turn off the partitioning optimization. */
942 ui_except
= targetm_common
.except_unwind_info (opts
);
944 if (opts
->x_flag_exceptions
945 && opts
->x_flag_reorder_blocks_and_partition
946 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
948 if (opts_set
->x_flag_reorder_blocks_and_partition
)
950 "%<-freorder-blocks-and-partition%> does not work "
951 "with exceptions on this architecture");
952 opts
->x_flag_reorder_blocks_and_partition
= 0;
953 opts
->x_flag_reorder_blocks
= 1;
956 /* If user requested unwind info, then turn off the partitioning
959 if (opts
->x_flag_unwind_tables
960 && !targetm_common
.unwind_tables_default
961 && opts
->x_flag_reorder_blocks_and_partition
962 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
964 if (opts_set
->x_flag_reorder_blocks_and_partition
)
966 "%<-freorder-blocks-and-partition%> does not support "
967 "unwind info on this architecture");
968 opts
->x_flag_reorder_blocks_and_partition
= 0;
969 opts
->x_flag_reorder_blocks
= 1;
972 /* If the target requested unwind info, then turn off the partitioning
973 optimization with a different message. Likewise, if the target does not
974 support named sections. */
976 if (opts
->x_flag_reorder_blocks_and_partition
977 && (!targetm_common
.have_named_sections
978 || (opts
->x_flag_unwind_tables
979 && targetm_common
.unwind_tables_default
980 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
982 if (opts_set
->x_flag_reorder_blocks_and_partition
)
984 "%<-freorder-blocks-and-partition%> does not work "
985 "on this architecture");
986 opts
->x_flag_reorder_blocks_and_partition
= 0;
987 opts
->x_flag_reorder_blocks
= 1;
991 /* Pipelining of outer loops is only possible when general pipelining
992 capabilities are requested. */
993 if (!opts
->x_flag_sel_sched_pipelining
)
994 opts
->x_flag_sel_sched_pipelining_outer_loops
= 0;
996 if (opts
->x_flag_conserve_stack
)
998 SET_OPTION_IF_UNSET (opts
, opts_set
, param_large_stack_frame
, 100);
999 SET_OPTION_IF_UNSET (opts
, opts_set
, param_stack_frame_growth
, 40);
1002 if (opts
->x_flag_lto
)
1005 opts
->x_flag_generate_lto
= 1;
1007 /* When generating IL, do not operate in whole-program mode.
1008 Otherwise, symbols will be privatized too early, causing link
1010 opts
->x_flag_whole_program
= 0;
1012 error_at (loc
, "LTO support has not been enabled in this configuration");
1014 if (!opts
->x_flag_fat_lto_objects
1015 && (!HAVE_LTO_PLUGIN
1016 || (opts_set
->x_flag_use_linker_plugin
1017 && !opts
->x_flag_use_linker_plugin
)))
1019 if (opts_set
->x_flag_fat_lto_objects
)
1020 error_at (loc
, "%<-fno-fat-lto-objects%> are supported only with "
1022 opts
->x_flag_fat_lto_objects
= 1;
1025 /* -gsplit-dwarf isn't compatible with LTO, see PR88389. */
1026 if (opts
->x_dwarf_split_debug_info
)
1028 inform (loc
, "%<-gsplit-dwarf%> is not supported with LTO,"
1030 opts
->x_dwarf_split_debug_info
= 0;
1034 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
1035 default value if they choose based on other options. */
1036 if (opts
->x_flag_split_stack
== -1)
1037 opts
->x_flag_split_stack
= 0;
1038 else if (opts
->x_flag_split_stack
)
1040 if (!targetm_common
.supports_split_stack (true, opts
))
1042 error_at (loc
, "%<-fsplit-stack%> is not supported by "
1043 "this compiler configuration");
1044 opts
->x_flag_split_stack
= 0;
1048 /* If stack splitting is turned on, and the user did not explicitly
1049 request function partitioning, turn off partitioning, as it
1050 confuses the linker when trying to handle partitioned split-stack
1051 code that calls a non-split-stack functions. But if partitioning
1052 was turned on explicitly just hope for the best. */
1053 if (opts
->x_flag_split_stack
1054 && opts
->x_flag_reorder_blocks_and_partition
)
1055 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_reorder_blocks_and_partition
, 0);
1057 if (opts
->x_flag_reorder_blocks_and_partition
)
1058 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_reorder_functions
, 1);
1060 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
1061 if (opts
->x_dwarf_split_debug_info
)
1062 opts
->x_debug_generate_pub_sections
= 2;
1064 if ((opts
->x_flag_sanitize
1065 & (SANITIZE_USER_ADDRESS
| SANITIZE_KERNEL_ADDRESS
)) == 0)
1067 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_COMPARE
)
1069 "%<-fsanitize=pointer-compare%> must be combined with "
1070 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1071 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_SUBTRACT
)
1073 "%<-fsanitize=pointer-subtract%> must be combined with "
1074 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1077 /* Userspace and kernel ASan conflict with each other. */
1078 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
1079 && (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
))
1080 error_at (loc
, "%qs is incompatible with %qs",
1081 "-fsanitize=address", "-fsanitize=kernel-address");
1083 /* And with TSan. */
1084 if ((opts
->x_flag_sanitize
& SANITIZE_ADDRESS
)
1085 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
1086 error_at (loc
, "%qs is incompatible with %qs",
1087 "-fsanitize=thread", "-fsanitize=address|kernel-address");
1089 if ((opts
->x_flag_sanitize
& SANITIZE_LEAK
)
1090 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
1091 error_at (loc
, "%qs is incompatible with %qs",
1092 "-fsanitize=leak", "-fsanitize=thread");
1094 /* Check error recovery for -fsanitize-recover option. */
1095 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1096 if ((opts
->x_flag_sanitize_recover
& sanitizer_opts
[i
].flag
)
1097 && !sanitizer_opts
[i
].can_recover
)
1098 error_at (loc
, "%<-fsanitize-recover=%s%> is not supported",
1099 sanitizer_opts
[i
].name
);
1101 /* When instrumenting the pointers, we don't want to remove
1102 the null pointer checks. */
1103 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
1104 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
1105 opts
->x_flag_delete_null_pointer_checks
= 0;
1107 /* Aggressive compiler optimizations may cause false negatives. */
1108 if (opts
->x_flag_sanitize
& ~(SANITIZE_LEAK
| SANITIZE_UNREACHABLE
))
1109 opts
->x_flag_aggressive_loop_optimizations
= 0;
1111 /* Enable -fsanitize-address-use-after-scope if address sanitizer is
1113 if (opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
1114 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_sanitize_address_use_after_scope
,
1117 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1119 if (opts
->x_flag_sanitize_address_use_after_scope
)
1121 if (opts
->x_flag_stack_reuse
!= SR_NONE
1122 && opts_set
->x_flag_stack_reuse
!= SR_NONE
)
1124 "%<-fsanitize-address-use-after-scope%> requires "
1125 "%<-fstack-reuse=none%> option");
1127 opts
->x_flag_stack_reuse
= SR_NONE
;
1130 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
) && opts
->x_flag_tm
)
1131 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1133 if ((opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) && opts
->x_flag_tm
)
1134 sorry ("transactional memory is not supported with "
1135 "%<-fsanitize=kernel-address%>");
1137 /* Currently live patching is not support for LTO. */
1138 if (opts
->x_flag_live_patching
&& opts
->x_flag_lto
)
1139 sorry ("live patching is not supported with LTO");
1141 /* Currently vtable verification is not supported for LTO */
1142 if (opts
->x_flag_vtable_verify
&& opts
->x_flag_lto
)
1143 sorry ("vtable verification is not supported with LTO");
1145 /* Control IPA optimizations based on different -flive-patching level. */
1146 if (opts
->x_flag_live_patching
)
1147 control_options_for_live_patching (opts
, opts_set
,
1148 opts
->x_flag_live_patching
,
1151 /* Unrolling all loops implies that standard loop unrolling must also
1153 if (opts
->x_flag_unroll_all_loops
)
1154 opts
->x_flag_unroll_loops
= 1;
1156 /* Allow cunroll to grow size accordingly. */
1157 if (!opts_set
->x_flag_cunroll_grow_size
)
1158 opts
->x_flag_cunroll_grow_size
1159 = (opts
->x_flag_unroll_loops
1160 || opts
->x_flag_peel_loops
1161 || opts
->x_optimize
>= 3);
1164 #define LEFT_COLUMN 27
1166 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1167 followed by word-wrapped HELP in a second column. */
1169 wrap_help (const char *help
,
1171 unsigned int item_width
,
1172 unsigned int columns
)
1174 unsigned int col_width
= LEFT_COLUMN
;
1175 unsigned int remaining
, room
, len
;
1177 remaining
= strlen (help
);
1181 room
= columns
- 3 - MAX (col_width
, item_width
);
1190 for (i
= 0; help
[i
]; i
++)
1192 if (i
>= room
&& len
!= remaining
)
1196 else if ((help
[i
] == '-' || help
[i
] == '/')
1197 && help
[i
+ 1] != ' '
1198 && i
> 0 && ISALPHA (help
[i
- 1]))
1203 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1205 while (help
[len
] == ' ')
1213 /* Data structure used to print list of valid option values. */
1215 class option_help_tuple
1218 option_help_tuple (int code
, vec
<const char *> values
):
1219 m_code (code
), m_values (values
)
1222 /* Code of an option. */
1225 /* List of possible values. */
1226 vec
<const char *> m_values
;
1229 /* Print help for a specific front-end, etc. */
1231 print_filtered_help (unsigned int include_flags
,
1232 unsigned int exclude_flags
,
1233 unsigned int any_flags
,
1234 unsigned int columns
,
1235 struct gcc_options
*opts
,
1236 unsigned int lang_mask
)
1241 bool displayed
= false;
1244 if (!opts
->x_help_printed
)
1245 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1247 if (!opts
->x_help_enum_printed
)
1248 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1250 auto_vec
<option_help_tuple
> help_tuples
;
1252 for (i
= 0; i
< cl_options_count
; i
++)
1254 const struct cl_option
*option
= cl_options
+ i
;
1259 if (include_flags
== 0
1260 || ((option
->flags
& include_flags
) != include_flags
))
1262 if ((option
->flags
& any_flags
) == 0)
1266 /* Skip unwanted switches. */
1267 if ((option
->flags
& exclude_flags
) != 0)
1270 /* The driver currently prints its own help text. */
1271 if ((option
->flags
& CL_DRIVER
) != 0
1272 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1273 | CL_COMMON
| CL_TARGET
)) == 0)
1276 /* If an option contains a language specification,
1277 exclude it from common unless all languages are present. */
1278 if ((include_flags
& CL_COMMON
)
1279 && !(option
->flags
& CL_DRIVER
)
1280 && (option
->flags
& CL_LANG_ALL
)
1281 && (option
->flags
& CL_LANG_ALL
) != CL_LANG_ALL
)
1285 /* Skip switches that have already been printed. */
1286 if (opts
->x_help_printed
[i
])
1289 opts
->x_help_printed
[i
] = true;
1291 help
= option
->help
;
1294 if (exclude_flags
& CL_UNDOCUMENTED
)
1297 help
= undocumented_msg
;
1300 /* Get the translation. */
1303 if (option
->alias_target
< N_OPTS
1304 && cl_options
[option
->alias_target
].help
)
1306 const struct cl_option
*target
= cl_options
+ option
->alias_target
;
1307 if (option
->help
== NULL
)
1309 /* The option is undocumented but is an alias for an option that
1310 is documented. If the option has alias arguments, then its
1311 purpose is to provide certain arguments to the other option, so
1312 inform the reader of this. Otherwise, point the reader to the
1313 other option in preference to the former. */
1315 if (option
->alias_arg
)
1317 if (option
->neg_alias_arg
)
1318 snprintf (new_help
, sizeof new_help
,
1319 _("Same as %s%s (or, in negated form, %s%s)."),
1320 target
->opt_text
, option
->alias_arg
,
1321 target
->opt_text
, option
->neg_alias_arg
);
1323 snprintf (new_help
, sizeof new_help
,
1325 target
->opt_text
, option
->alias_arg
);
1328 snprintf (new_help
, sizeof new_help
,
1334 /* For documented options with aliases, mention the aliased
1335 option's name for reference. */
1336 snprintf (new_help
, sizeof new_help
,
1337 _("%s Same as %s."),
1338 help
, cl_options
[option
->alias_target
].opt_text
);
1344 if (option
->warn_message
)
1346 /* Mention that the use of the option will trigger a warning. */
1347 if (help
== new_help
)
1348 snprintf (new_help
+ strlen (new_help
),
1349 sizeof new_help
- strlen (new_help
),
1350 " %s", _(use_diagnosed_msg
));
1352 snprintf (new_help
, sizeof new_help
,
1353 "%s %s", help
, _(use_diagnosed_msg
));
1358 /* Find the gap between the name of the
1359 option and its descriptive text. */
1360 tab
= strchr (help
, '\t');
1369 opt
= option
->opt_text
;
1373 /* With the -Q option enabled we change the descriptive text associated
1374 with an option to be an indication of its current setting. */
1375 if (!opts
->x_quiet_flag
)
1377 void *flag_var
= option_flag_var (i
, opts
);
1379 if (len
< (LEFT_COLUMN
+ 2))
1380 strcpy (new_help
, "\t\t");
1382 strcpy (new_help
, "\t");
1384 /* Set to print whether the option is enabled or disabled,
1385 or, if it's an alias for another option, the name of
1386 the aliased option. */
1387 bool print_state
= false;
1389 if (flag_var
!= NULL
1390 && option
->var_type
!= CLVC_DEFER
)
1392 /* If OPTION is only available for a specific subset
1393 of languages other than this one, mention them. */
1394 bool avail_for_lang
= true;
1395 if (unsigned langset
= option
->flags
& CL_LANG_ALL
)
1397 if (!(langset
& lang_mask
))
1399 avail_for_lang
= false;
1400 strcat (new_help
, _("[available in "));
1401 for (unsigned i
= 0, n
= 0; (1U << i
) < CL_LANG_ALL
; ++i
)
1402 if (langset
& (1U << i
))
1405 strcat (new_help
, ", ");
1406 strcat (new_help
, lang_names
[i
]);
1408 strcat (new_help
, "]");
1411 if (!avail_for_lang
)
1412 ; /* Print nothing else if the option is not available
1413 in the current language. */
1414 else if (option
->flags
& CL_JOINED
)
1416 if (option
->var_type
== CLVC_STRING
)
1418 if (* (const char **) flag_var
!= NULL
)
1419 snprintf (new_help
+ strlen (new_help
),
1420 sizeof (new_help
) - strlen (new_help
),
1421 "%s", * (const char **) flag_var
);
1423 else if (option
->var_type
== CLVC_ENUM
)
1425 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1427 const char *arg
= NULL
;
1429 value
= e
->get (flag_var
);
1430 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1432 arg
= _("[default]");
1433 snprintf (new_help
+ strlen (new_help
),
1434 sizeof (new_help
) - strlen (new_help
),
1439 if (option
->cl_host_wide_int
)
1440 sprintf (new_help
+ strlen (new_help
),
1441 _("%llu bytes"), (unsigned long long)
1442 *(unsigned HOST_WIDE_INT
*) flag_var
);
1444 sprintf (new_help
+ strlen (new_help
),
1445 "%i", * (int *) flag_var
);
1452 /* When there is no argument, print the option state only
1453 if the option takes no argument. */
1454 print_state
= !(option
->flags
& CL_JOINED
);
1458 if (option
->alias_target
< N_OPTS
1459 && option
->alias_target
!= OPT_SPECIAL_warn_removed
1460 && option
->alias_target
!= OPT_SPECIAL_ignore
1461 && option
->alias_target
!= OPT_SPECIAL_input_file
1462 && option
->alias_target
!= OPT_SPECIAL_program_name
1463 && option
->alias_target
!= OPT_SPECIAL_unknown
)
1465 const struct cl_option
*target
1466 = &cl_options
[option
->alias_target
];
1467 sprintf (new_help
+ strlen (new_help
), "%s%s",
1469 option
->alias_arg
? option
->alias_arg
: "");
1471 else if (option
->alias_target
== OPT_SPECIAL_ignore
)
1472 strcat (new_help
, ("[ignored]"));
1475 /* Print the state for an on/off option. */
1476 int ena
= option_enabled (i
, lang_mask
, opts
);
1478 strcat (new_help
, _("[enabled]"));
1480 strcat (new_help
, _("[disabled]"));
1487 if (option
->range_max
!= -1)
1490 snprintf (b
, sizeof (b
), "<%d,%d>", option
->range_min
,
1492 opt
= concat (opt
, b
, NULL
);
1496 wrap_help (help
, opt
, len
, columns
);
1499 if (option
->var_type
== CLVC_ENUM
1500 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1501 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1504 vec
<const char *> option_values
1505 = targetm_common
.get_valid_option_values (i
, NULL
);
1506 if (!option_values
.is_empty ())
1507 help_tuples
.safe_push (option_help_tuple (i
, option_values
));
1513 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1516 printf (_(" No options with the desired characteristics were found\n"));
1521 /* PR 31349: Tell the user how to see all of the
1522 options supported by a specific front end. */
1523 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1524 if ((1U << i
) & langs
)
1525 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1526 lang_names
[i
], lang_names
[i
]);
1530 else if (! displayed
)
1531 printf (_(" All options with the desired characteristics have already been displayed\n"));
1535 /* Print details of enumerated option arguments, if those
1536 enumerations have help text headings provided. If no help text
1537 is provided, presume that the possible values are listed in the
1538 help text for the relevant options. */
1539 for (i
= 0; i
< cl_enums_count
; i
++)
1541 unsigned int j
, pos
;
1543 if (opts
->x_help_enum_printed
[i
] != 1)
1545 if (cl_enums
[i
].help
== NULL
)
1547 printf (" %s\n ", _(cl_enums
[i
].help
));
1549 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1551 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1553 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1555 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1565 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1570 opts
->x_help_enum_printed
[i
] = 2;
1573 for (unsigned i
= 0; i
< help_tuples
.length (); i
++)
1575 const struct cl_option
*option
= cl_options
+ help_tuples
[i
].m_code
;
1576 printf (_(" Known valid arguments for %s option:\n "),
1578 for (unsigned j
= 0; j
< help_tuples
[i
].m_values
.length (); j
++)
1579 printf (" %s", help_tuples
[i
].m_values
[j
]);
1584 /* Display help for a specified type of option.
1585 The options must have ALL of the INCLUDE_FLAGS set
1586 ANY of the flags in the ANY_FLAGS set
1587 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1588 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1590 print_specific_help (unsigned int include_flags
,
1591 unsigned int exclude_flags
,
1592 unsigned int any_flags
,
1593 struct gcc_options
*opts
,
1594 unsigned int lang_mask
)
1596 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1597 const char * description
= NULL
;
1598 const char * descrip_extra
= "";
1602 /* Sanity check: Make sure that we do not have more
1603 languages than we have bits available to enumerate them. */
1604 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1606 /* If we have not done so already, obtain
1607 the desired maximum width of the output. */
1608 if (opts
->x_help_columns
== 0)
1610 opts
->x_help_columns
= get_terminal_width ();
1611 if (opts
->x_help_columns
== INT_MAX
)
1612 /* Use a reasonable default. */
1613 opts
->x_help_columns
= 80;
1616 /* Decide upon the title for the options that we are going to display. */
1617 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1619 switch (flag
& include_flags
)
1626 description
= _("The following options are target specific");
1629 description
= _("The following options control compiler warning messages");
1631 case CL_OPTIMIZATION
:
1632 description
= _("The following options control optimizations");
1635 description
= _("The following options are language-independent");
1638 description
= _("The following options control parameters");
1641 if (i
>= cl_lang_count
)
1643 if (exclude_flags
& all_langs_mask
)
1644 description
= _("The following options are specific to just the language ");
1646 description
= _("The following options are supported by the language ");
1647 descrip_extra
= lang_names
[i
];
1652 if (description
== NULL
)
1656 if (include_flags
& CL_UNDOCUMENTED
)
1657 description
= _("The following options are not documented");
1658 else if (include_flags
& CL_SEPARATE
)
1659 description
= _("The following options take separate arguments");
1660 else if (include_flags
& CL_JOINED
)
1661 description
= _("The following options take joined arguments");
1664 internal_error ("unrecognized %<include_flags 0x%x%> passed "
1665 "to %<print_specific_help%>",
1672 if (any_flags
& all_langs_mask
)
1673 description
= _("The following options are language-related");
1675 description
= _("The following options are language-independent");
1679 printf ("%s%s:\n", description
, descrip_extra
);
1680 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
1681 opts
->x_help_columns
, opts
, lang_mask
);
1684 /* Enable FDO-related flags. */
1687 enable_fdo_optimizations (struct gcc_options
*opts
,
1688 struct gcc_options
*opts_set
,
1691 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_branch_probabilities
, value
);
1692 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
1693 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_loops
, value
);
1694 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_peel_loops
, value
);
1695 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tracer
, value
);
1696 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_value_profile_transformations
,
1698 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
1699 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp
, value
);
1702 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp_clone
, 1);
1703 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, 1);
1705 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_predictive_commoning
, value
);
1706 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_split_loops
, value
);
1707 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unswitch_loops
, value
);
1708 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_gcse_after_reload
, value
);
1709 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_vectorize
, value
);
1710 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_slp_vectorize
, value
);
1711 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_version_loops_for_strides
, value
);
1712 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_vect_cost_model
,
1713 VECT_COST_MODEL_DYNAMIC
);
1714 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribute_patterns
,
1716 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_loop_interchange
, value
);
1717 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_jam
, value
);
1718 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribution
, value
);
1721 /* -f{,no-}sanitize{,-recover}= suboptions. */
1722 const struct sanitizer_opts_s sanitizer_opts
[] =
1724 #define SANITIZER_OPT(name, flags, recover) \
1725 { #name, flags, sizeof #name - 1, recover }
1726 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true),
1727 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
1729 SANITIZER_OPT (pointer
-compare
, SANITIZE_POINTER_COMPARE
, true),
1730 SANITIZER_OPT (pointer
-subtract
, SANITIZE_POINTER_SUBTRACT
, true),
1731 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false),
1732 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false),
1733 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true),
1734 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true),
1735 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true),
1736 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true),
1737 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true),
1738 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false),
1739 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true),
1740 SANITIZER_OPT (return, SANITIZE_RETURN
, false),
1741 SANITIZER_OPT (null
, SANITIZE_NULL
, true),
1742 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true),
1743 SANITIZER_OPT (bool, SANITIZE_BOOL
, true),
1744 SANITIZER_OPT (enum, SANITIZE_ENUM
, true),
1745 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true),
1746 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true),
1747 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true),
1748 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true),
1749 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true),
1750 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true),
1751 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
1753 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true),
1754 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true),
1755 SANITIZER_OPT (pointer
-overflow
, SANITIZE_POINTER_OVERFLOW
, true),
1756 SANITIZER_OPT (builtin
, SANITIZE_BUILTIN
, true),
1757 SANITIZER_OPT (all
, ~0U, true),
1758 #undef SANITIZER_OPT
1759 { NULL
, 0U, 0UL, false }
1762 /* -f{,no-}sanitize-coverage= suboptions. */
1763 const struct sanitizer_opts_s coverage_sanitizer_opts
[] =
1765 #define COVERAGE_SANITIZER_OPT(name, flags) \
1766 { #name, flags, sizeof #name - 1, true }
1767 COVERAGE_SANITIZER_OPT (trace
-pc
, SANITIZE_COV_TRACE_PC
),
1768 COVERAGE_SANITIZER_OPT (trace
-cmp
, SANITIZE_COV_TRACE_CMP
),
1769 #undef COVERAGE_SANITIZER_OPT
1770 { NULL
, 0U, 0UL, false }
1773 /* -fzero-call-used-regs= suboptions. */
1774 const struct zero_call_used_regs_opts_s zero_call_used_regs_opts
[] =
1776 #define ZERO_CALL_USED_REGS_OPT(name, flags) \
1778 ZERO_CALL_USED_REGS_OPT (skip
, zero_regs_flags::SKIP
),
1779 ZERO_CALL_USED_REGS_OPT (used
-gpr
-arg
, zero_regs_flags::USED_GPR_ARG
),
1780 ZERO_CALL_USED_REGS_OPT (used
-gpr
, zero_regs_flags::USED_GPR
),
1781 ZERO_CALL_USED_REGS_OPT (used
-arg
, zero_regs_flags::USED_ARG
),
1782 ZERO_CALL_USED_REGS_OPT (used
, zero_regs_flags::USED
),
1783 ZERO_CALL_USED_REGS_OPT (all
-gpr
-arg
, zero_regs_flags::ALL_GPR_ARG
),
1784 ZERO_CALL_USED_REGS_OPT (all
-gpr
, zero_regs_flags::ALL_GPR
),
1785 ZERO_CALL_USED_REGS_OPT (all
-arg
, zero_regs_flags::ALL_ARG
),
1786 ZERO_CALL_USED_REGS_OPT (all
, zero_regs_flags::ALL
),
1787 #undef ZERO_CALL_USED_REGS_OPT
1791 /* A struct for describing a run of chars within a string. */
1793 class string_fragment
1796 string_fragment (const char *start
, size_t len
)
1797 : m_start (start
), m_len (len
) {}
1799 const char *m_start
;
1803 /* Specialization of edit_distance_traits for string_fragment,
1804 for use by get_closest_sanitizer_option. */
1807 struct edit_distance_traits
<const string_fragment
&>
1809 static size_t get_length (const string_fragment
&fragment
)
1811 return fragment
.m_len
;
1814 static const char *get_string (const string_fragment
&fragment
)
1816 return fragment
.m_start
;
1820 /* Given ARG, an unrecognized sanitizer option, return the best
1821 matching sanitizer option, or NULL if there isn't one.
1822 OPTS is array of candidate sanitizer options.
1823 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or
1824 OPT_fsanitize_coverage_.
1825 VALUE is non-zero for the regular form of the option, zero
1826 for the "no-" form (e.g. "-fno-sanitize-recover="). */
1829 get_closest_sanitizer_option (const string_fragment
&arg
,
1830 const struct sanitizer_opts_s
*opts
,
1831 enum opt_code code
, int value
)
1833 best_match
<const string_fragment
&, const char*> bm (arg
);
1834 for (int i
= 0; opts
[i
].name
!= NULL
; ++i
)
1836 /* -fsanitize=all is not valid, so don't offer it. */
1837 if (code
== OPT_fsanitize_
1838 && opts
[i
].flag
== ~0U
1842 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
1843 don't offer the non-recoverable options. */
1844 if (code
== OPT_fsanitize_recover_
1845 && !opts
[i
].can_recover
1849 bm
.consider (opts
[i
].name
);
1851 return bm
.get_best_meaningful_candidate ();
1854 /* Parse comma separated sanitizer suboptions from P for option SCODE,
1855 adjust previous FLAGS and return new ones. If COMPLAIN is false,
1856 don't issue diagnostics. */
1859 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
1860 unsigned int flags
, int value
, bool complain
)
1862 enum opt_code code
= (enum opt_code
) scode
;
1864 const struct sanitizer_opts_s
*opts
;
1865 if (code
== OPT_fsanitize_coverage_
)
1866 opts
= coverage_sanitizer_opts
;
1868 opts
= sanitizer_opts
;
1874 const char *comma
= strchr (p
, ',');
1886 /* Check to see if the string matches an option class name. */
1887 for (i
= 0; opts
[i
].name
!= NULL
; ++i
)
1888 if (len
== opts
[i
].len
&& memcmp (p
, opts
[i
].name
, len
) == 0)
1890 /* Handle both -fsanitize and -fno-sanitize cases. */
1891 if (value
&& opts
[i
].flag
== ~0U)
1893 if (code
== OPT_fsanitize_
)
1896 error_at (loc
, "%<-fsanitize=all%> option is not valid");
1899 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
1900 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
1904 /* Do not enable -fsanitize-recover=unreachable and
1905 -fsanitize-recover=return if -fsanitize-recover=undefined
1907 if (code
== OPT_fsanitize_recover_
1908 && opts
[i
].flag
== SANITIZE_UNDEFINED
)
1909 flags
|= (SANITIZE_UNDEFINED
1910 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
1912 flags
|= opts
[i
].flag
;
1915 flags
&= ~opts
[i
].flag
;
1920 if (! found
&& complain
)
1923 = get_closest_sanitizer_option (string_fragment (p
, len
),
1927 if (code
== OPT_fsanitize_recover_
)
1928 suffix
= "-recover";
1929 else if (code
== OPT_fsanitize_coverage_
)
1930 suffix
= "-coverage";
1936 "unrecognized argument to %<-f%ssanitize%s=%> "
1937 "option: %q.*s; did you mean %qs?",
1939 suffix
, (int) len
, p
, hint
);
1942 "unrecognized argument to %<-f%ssanitize%s=%> option: "
1943 "%q.*s", value
? "" : "no-",
1944 suffix
, (int) len
, p
);
1954 /* Parse string values of no_sanitize attribute passed in VALUE.
1955 Values are separated with comma. */
1958 parse_no_sanitize_attribute (char *value
)
1960 unsigned int flags
= 0;
1962 char *q
= strtok (value
, ",");
1966 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1967 if (strcmp (sanitizer_opts
[i
].name
, q
) == 0)
1969 flags
|= sanitizer_opts
[i
].flag
;
1970 if (sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
1971 flags
|= SANITIZE_UNDEFINED_NONDEFAULT
;
1975 if (sanitizer_opts
[i
].name
== NULL
)
1976 warning (OPT_Wattributes
,
1977 "%qs attribute directive ignored", q
);
1979 q
= strtok (NULL
, ",");
1985 /* Parse -fzero-call-used-regs suboptions from ARG, return the FLAGS. */
1988 parse_zero_call_used_regs_options (const char *arg
)
1990 unsigned int flags
= 0;
1992 /* Check to see if the string matches a sub-option name. */
1993 for (unsigned int i
= 0; zero_call_used_regs_opts
[i
].name
!= NULL
; ++i
)
1994 if (strcmp (arg
, zero_call_used_regs_opts
[i
].name
) == 0)
1996 flags
= zero_call_used_regs_opts
[i
].flag
;
2001 error ("unrecognized argument to %<-fzero-call-used-regs=%>: %qs", arg
);
2006 /* Parse -falign-NAME format for a FLAG value. Return individual
2007 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
2008 set, print error message at LOC location. */
2011 parse_and_check_align_values (const char *flag
,
2013 auto_vec
<unsigned> &result_values
,
2017 char *str
= xstrdup (flag
);
2018 for (char *p
= strtok (str
, ":"); p
; p
= strtok (NULL
, ":"))
2021 int v
= strtol (p
, &end
, 10);
2022 if (*end
!= '\0' || v
< 0)
2025 error_at (loc
, "invalid arguments for %<-falign-%s%> option: %qs",
2031 result_values
.safe_push ((unsigned)v
);
2036 /* Check that we have a correct number of values. */
2037 if (result_values
.is_empty () || result_values
.length () > 4)
2040 error_at (loc
, "invalid number of arguments for %<-falign-%s%> "
2041 "option: %qs", name
, flag
);
2045 for (unsigned i
= 0; i
< result_values
.length (); i
++)
2046 if (result_values
[i
] > MAX_CODE_ALIGN_VALUE
)
2049 error_at (loc
, "%<-falign-%s%> is not between 0 and %d",
2050 name
, MAX_CODE_ALIGN_VALUE
);
2057 /* Check that alignment value FLAG for -falign-NAME is valid at a given
2058 location LOC. OPT_STR points to the stored -falign-NAME=argument and
2059 OPT_FLAG points to the associated -falign-NAME on/off flag. */
2062 check_alignment_argument (location_t loc
, const char *flag
, const char *name
,
2063 int *opt_flag
, const char **opt_str
)
2065 auto_vec
<unsigned> align_result
;
2066 parse_and_check_align_values (flag
, name
, align_result
, true, loc
);
2068 if (align_result
.length() >= 1 && align_result
[0] == 0)
2075 /* Print help when OPT__help_ is set. */
2078 print_help (struct gcc_options
*opts
, unsigned int lang_mask
,
2079 const char *help_option_argument
)
2081 const char *a
= help_option_argument
;
2082 unsigned int include_flags
= 0;
2083 /* Note - by default we include undocumented options when listing
2084 specific classes. If you only want to see documented options
2085 then add ",^undocumented" to the --help= option. E.g.:
2087 --help=target,^undocumented */
2088 unsigned int exclude_flags
= 0;
2090 if (lang_mask
== CL_DRIVER
)
2093 /* Walk along the argument string, parsing each word in turn.
2095 arg = [^]{word}[,{arg}]
2096 word = {optimizers|target|warnings|undocumented|
2097 params|common|<language>} */
2107 { "optimizers", CL_OPTIMIZATION
},
2108 { "target", CL_TARGET
},
2109 { "warnings", CL_WARNING
},
2110 { "undocumented", CL_UNDOCUMENTED
},
2111 { "params", CL_PARAMS
},
2112 { "joined", CL_JOINED
},
2113 { "separate", CL_SEPARATE
},
2114 { "common", CL_COMMON
},
2117 unsigned int *pflags
;
2119 unsigned int lang_flag
, specific_flag
;
2128 error ("missing argument to %qs", "--help=^");
2131 pflags
= &exclude_flags
;
2134 pflags
= &include_flags
;
2136 comma
= strchr (a
, ',');
2147 /* Check to see if the string matches an option class name. */
2148 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
2149 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
2151 specific_flag
= specifics
[i
].flag
;
2155 /* Check to see if the string matches a language name.
2156 Note - we rely upon the alpha-sorted nature of the entries in
2157 the lang_names array, specifically that shorter names appear
2158 before their longer variants. (i.e. C before C++). That way
2159 when we are attempting to match --help=c for example we will
2160 match with C first and not C++. */
2161 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
2162 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
2164 lang_flag
= 1U << i
;
2168 if (specific_flag
!= 0)
2171 *pflags
|= specific_flag
;
2174 /* The option's argument matches both the start of a
2175 language name and the start of an option class name.
2176 We have a special case for when the user has
2177 specified "--help=c", but otherwise we have to issue
2179 if (strncasecmp (a
, "c", len
) == 0)
2180 *pflags
|= lang_flag
;
2183 "%<--help%> argument %q.*s is ambiguous, "
2184 "please be more specific",
2188 else if (lang_flag
!= 0)
2189 *pflags
|= lang_flag
;
2192 "unrecognized argument to %<--help=%> option: %q.*s",
2200 /* We started using PerFunction/Optimization for parameters and
2201 a warning. We should exclude these from optimization options. */
2202 if (include_flags
& CL_OPTIMIZATION
)
2203 exclude_flags
|= CL_WARNING
;
2204 if (!(include_flags
& CL_PARAMS
))
2205 exclude_flags
|= CL_PARAMS
;
2208 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
2212 /* Handle target- and language-independent options. Return zero to
2213 generate an "unknown option" message. Only options that need
2214 extra handling need to be listed here; if you simply want
2215 DECODED->value assigned to a variable, it happens automatically. */
2218 common_handle_option (struct gcc_options
*opts
,
2219 struct gcc_options
*opts_set
,
2220 const struct cl_decoded_option
*decoded
,
2221 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
2223 const struct cl_option_handlers
*handlers
,
2224 diagnostic_context
*dc
,
2225 void (*target_option_override_hook
) (void))
2227 size_t scode
= decoded
->opt_index
;
2228 const char *arg
= decoded
->arg
;
2229 HOST_WIDE_INT value
= decoded
->value
;
2230 enum opt_code code
= (enum opt_code
) scode
;
2232 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
2238 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
2239 unsigned int undoc_mask
;
2242 if (lang_mask
== CL_DRIVER
)
2245 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
2248 target_option_override_hook ();
2249 /* First display any single language specific options. */
2250 for (i
= 0; i
< cl_lang_count
; i
++)
2252 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
2254 /* Next display any multi language specific options. */
2255 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
2256 /* Then display any remaining, non-language options. */
2257 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
2259 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
2260 opts
->x_exit_after_options
= true;
2264 case OPT__target_help
:
2265 if (lang_mask
== CL_DRIVER
)
2268 target_option_override_hook ();
2269 print_specific_help (CL_TARGET
, CL_UNDOCUMENTED
, 0, opts
, lang_mask
);
2270 opts
->x_exit_after_options
= true;
2275 help_option_arguments
.safe_push (arg
);
2276 opts
->x_exit_after_options
= true;
2281 if (lang_mask
== CL_DRIVER
)
2284 opts
->x_exit_after_options
= true;
2287 case OPT__completion_
:
2290 case OPT_fsanitize_
:
2291 opts
->x_flag_sanitize
2292 = parse_sanitizer_options (arg
, loc
, code
,
2293 opts
->x_flag_sanitize
, value
, true);
2295 /* Kernel ASan implies normal ASan but does not yet support
2297 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
2299 SET_OPTION_IF_UNSET (opts
, opts_set
,
2300 param_asan_instrumentation_with_call_threshold
,
2302 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_globals
, 0);
2303 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_stack
, 0);
2304 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_protect_allocas
, 0);
2305 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_use_after_return
, 0);
2309 case OPT_fsanitize_recover_
:
2310 opts
->x_flag_sanitize_recover
2311 = parse_sanitizer_options (arg
, loc
, code
,
2312 opts
->x_flag_sanitize_recover
, value
, true);
2315 case OPT_fasan_shadow_offset_
:
2319 case OPT_fsanitize_address_use_after_scope
:
2320 opts
->x_flag_sanitize_address_use_after_scope
= value
;
2323 case OPT_fsanitize_recover
:
2325 opts
->x_flag_sanitize_recover
2326 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)
2327 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2329 opts
->x_flag_sanitize_recover
2330 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2333 case OPT_fsanitize_coverage_
:
2334 opts
->x_flag_sanitize_coverage
2335 = parse_sanitizer_options (arg
, loc
, code
,
2336 opts
->x_flag_sanitize_coverage
, value
, true);
2343 /* Currently handled in a prescan. */
2347 dc
->warning_as_error_requested
= value
;
2351 if (lang_mask
== CL_DRIVER
)
2354 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
2355 opts
, opts_set
, loc
, dc
);
2358 case OPT_Wfatal_errors
:
2359 dc
->fatal_errors
= value
;
2362 case OPT_Wstack_usage_
:
2363 opts
->x_flag_stack_usage_info
= value
!= -1;
2366 case OPT_Wstrict_aliasing
:
2367 set_Wstrict_aliasing (opts
, value
);
2370 case OPT_Wstrict_overflow
:
2371 opts
->x_warn_strict_overflow
= (value
2372 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2376 case OPT_Wsystem_headers
:
2377 dc
->dc_warn_system_headers
= value
;
2381 opts
->x_flag_gen_aux_info
= 1;
2385 decode_d_option (arg
, opts
, loc
, dc
);
2388 case OPT_fcall_used_
:
2389 case OPT_fcall_saved_
:
2397 case OPT_fdebug_prefix_map_
:
2398 case OPT_ffile_prefix_map_
:
2402 case OPT_fcallgraph_info
:
2403 opts
->x_flag_callgraph_info
= CALLGRAPH_INFO_NAKED
;
2406 case OPT_fcallgraph_info_
:
2409 my_arg
= xstrdup (arg
);
2410 p
= strtok (my_arg
, ",");
2413 if (strcmp (p
, "su") == 0)
2415 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_STACK_USAGE
;
2416 opts
->x_flag_stack_usage_info
= true;
2418 else if (strcmp (p
, "da") == 0)
2419 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_DYNAMIC_ALLOC
;
2422 p
= strtok (NULL
, ",");
2428 case OPT_fdiagnostics_show_location_
:
2429 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2432 case OPT_fdiagnostics_show_caret
:
2433 dc
->show_caret
= value
;
2436 case OPT_fdiagnostics_show_labels
:
2437 dc
->show_labels_p
= value
;
2440 case OPT_fdiagnostics_show_line_numbers
:
2441 dc
->show_line_numbers_p
= value
;
2444 case OPT_fdiagnostics_color_
:
2445 diagnostic_color_init (dc
, value
);
2448 case OPT_fdiagnostics_urls_
:
2449 diagnostic_urls_init (dc
, value
);
2452 case OPT_fdiagnostics_format_
:
2453 diagnostic_output_format_init (dc
,
2454 (enum diagnostics_output_format
)value
);
2457 case OPT_fdiagnostics_parseable_fixits
:
2458 dc
->parseable_fixits_p
= value
;
2461 case OPT_fdiagnostics_column_unit_
:
2462 dc
->column_unit
= (enum diagnostics_column_unit
)value
;
2465 case OPT_fdiagnostics_column_origin_
:
2466 dc
->column_origin
= value
;
2469 case OPT_fdiagnostics_show_cwe
:
2470 dc
->show_cwe
= value
;
2473 case OPT_fdiagnostics_path_format_
:
2474 dc
->path_format
= (enum diagnostic_path_format
)value
;
2477 case OPT_fdiagnostics_show_path_depths
:
2478 dc
->show_path_depths
= value
;
2481 case OPT_fdiagnostics_show_option
:
2482 dc
->show_option_requested
= value
;
2485 case OPT_fdiagnostics_minimum_margin_width_
:
2486 dc
->min_margin_width
= value
;
2493 case OPT_ffast_math
:
2494 set_fast_math_flags (opts
, value
);
2497 case OPT_funsafe_math_optimizations
:
2498 set_unsafe_math_optimizations_flags (opts
, value
);
2505 case OPT_finline_limit_
:
2506 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_single
,
2508 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_auto
,
2512 case OPT_finstrument_functions_exclude_function_list_
:
2513 add_comma_separated_to_vector
2514 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2517 case OPT_finstrument_functions_exclude_file_list_
:
2518 add_comma_separated_to_vector
2519 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2522 case OPT_fmessage_length_
:
2523 pp_set_line_maximum_length (dc
->printer
, value
);
2524 diagnostic_set_caret_max_width (dc
, value
);
2528 case OPT_fopt_info_
:
2536 #ifndef ACCEL_COMPILER
2537 case OPT_foffload_abi_
:
2538 error_at (loc
, "%<-foffload-abi%> option can be specified only for "
2539 "offload compiler");
2543 case OPT_fpack_struct_
:
2544 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2546 "structure alignment must be a small power of two, not %wu",
2549 opts
->x_initial_max_fld_align
= value
;
2553 case OPT_fplugin_arg_
:
2557 case OPT_fprofile_use_
:
2558 opts
->x_profile_data_prefix
= xstrdup (arg
);
2559 opts
->x_flag_profile_use
= true;
2561 /* No break here - do -fprofile-use processing. */
2563 case OPT_fprofile_use
:
2564 enable_fdo_optimizations (opts
, opts_set
, value
);
2565 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_reorder_functions
,
2567 /* Indirect call profiling should do all useful transformations
2568 speculative devirtualization does. */
2569 if (opts
->x_flag_value_profile_transformations
)
2570 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_devirtualize_speculatively
,
2574 case OPT_fauto_profile_
:
2575 opts
->x_auto_profile_file
= xstrdup (arg
);
2576 opts
->x_flag_auto_profile
= true;
2578 /* No break here - do -fauto-profile processing. */
2580 case OPT_fauto_profile
:
2581 enable_fdo_optimizations (opts
, opts_set
, value
);
2582 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_correction
, value
);
2583 SET_OPTION_IF_UNSET (opts
, opts_set
,
2584 param_early_inliner_max_iterations
, 10);
2587 case OPT_fprofile_generate_
:
2588 opts
->x_profile_data_prefix
= xstrdup (arg
);
2590 /* No break here - do -fprofile-generate processing. */
2592 case OPT_fprofile_generate
:
2593 SET_OPTION_IF_UNSET (opts
, opts_set
, profile_arc_flag
, value
);
2594 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
2595 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
2596 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, value
);
2599 case OPT_fprofile_info_section
:
2600 opts
->x_profile_info_section
= ".gcov_info";
2603 case OPT_fpatchable_function_entry_
:
2605 char *patch_area_arg
= xstrdup (arg
);
2606 char *comma
= strchr (patch_area_arg
, ',');
2610 function_entry_patch_area_size
=
2611 integral_argument (patch_area_arg
);
2612 function_entry_patch_area_start
=
2613 integral_argument (comma
+ 1);
2617 function_entry_patch_area_size
=
2618 integral_argument (patch_area_arg
);
2619 function_entry_patch_area_start
= 0;
2621 if (function_entry_patch_area_size
< 0
2622 || function_entry_patch_area_size
> USHRT_MAX
2623 || function_entry_patch_area_start
< 0
2624 || function_entry_patch_area_start
> USHRT_MAX
2625 || function_entry_patch_area_size
2626 < function_entry_patch_area_start
)
2627 error ("invalid arguments for %<-fpatchable-function-entry%>");
2628 free (patch_area_arg
);
2632 case OPT_ftree_vectorize
:
2633 /* Automatically sets -ftree-loop-vectorize and
2634 -ftree-slp-vectorize. Nothing more to do here. */
2636 case OPT_fzero_call_used_regs_
:
2637 opts
->x_flag_zero_call_used_regs
2638 = parse_zero_call_used_regs_options (arg
);
2641 case OPT_fshow_column
:
2642 dc
->show_column
= value
;
2645 case OPT_frandom_seed
:
2646 /* The real switch is -fno-random-seed. */
2652 case OPT_frandom_seed_
:
2656 case OPT_fsched_verbose_
:
2657 #ifdef INSN_SCHEDULING
2658 /* Handled with Var in common.opt. */
2664 case OPT_fsched_stalled_insns_
:
2665 opts
->x_flag_sched_stalled_insns
= value
;
2666 if (opts
->x_flag_sched_stalled_insns
== 0)
2667 opts
->x_flag_sched_stalled_insns
= -1;
2670 case OPT_fsched_stalled_insns_dep_
:
2671 opts
->x_flag_sched_stalled_insns_dep
= value
;
2674 case OPT_fstack_check_
:
2675 if (!strcmp (arg
, "no"))
2676 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
2677 else if (!strcmp (arg
, "generic"))
2678 /* This is the old stack checking method. */
2679 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2680 ? FULL_BUILTIN_STACK_CHECK
2681 : GENERIC_STACK_CHECK
;
2682 else if (!strcmp (arg
, "specific"))
2683 /* This is the new stack checking method. */
2684 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2685 ? FULL_BUILTIN_STACK_CHECK
2686 : STACK_CHECK_STATIC_BUILTIN
2687 ? STATIC_BUILTIN_STACK_CHECK
2688 : GENERIC_STACK_CHECK
;
2690 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
2693 case OPT_fstack_limit
:
2694 /* The real switch is -fno-stack-limit. */
2700 case OPT_fstack_limit_register_
:
2701 case OPT_fstack_limit_symbol_
:
2705 case OPT_fstack_usage
:
2706 opts
->x_flag_stack_usage
= value
;
2707 opts
->x_flag_stack_usage_info
= value
!= 0;
2711 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
2716 if (arg
&& strlen (arg
) != 0)
2718 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
2719 "use %<-gdwarf-%s%> for DWARF version "
2720 "or %<-gdwarf%> %<-g%s%> for debug level", arg
, arg
, arg
);
2724 value
= opts
->x_dwarf_version
;
2728 if (value
< 2 || value
> 5)
2729 error_at (loc
, "dwarf version %wu is not supported", value
);
2731 opts
->x_dwarf_version
= value
;
2732 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
2736 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
2741 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
, opts
, opts_set
,
2746 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2751 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
, opts
, opts_set
,
2757 /* Handled completely via specs. */
2760 case OPT_pedantic_errors
:
2761 dc
->pedantic_errors
= 1;
2762 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
2764 handlers
, opts
, opts_set
,
2769 opts
->x_flag_lto
= value
? "" : NULL
;
2773 if (strcmp (arg
, "none") != 0
2774 && strcmp (arg
, "jobserver") != 0
2775 && strcmp (arg
, "auto") != 0
2778 "unrecognized argument to %<-flto=%> option: %qs", arg
);
2782 dc
->dc_inhibit_warnings
= true;
2785 case OPT_fmax_errors_
:
2786 dc
->max_errors
= value
;
2789 case OPT_fuse_ld_bfd
:
2790 case OPT_fuse_ld_gold
:
2791 case OPT_fuse_ld_lld
:
2792 case OPT_fuse_linker_plugin
:
2793 /* No-op. Used by the driver and passed to us because it starts with f.*/
2798 opts
->x_flag_trapv
= 0;
2803 opts
->x_flag_wrapv
= 0;
2806 case OPT_fstrict_overflow
:
2807 opts
->x_flag_wrapv
= !value
;
2808 opts
->x_flag_wrapv_pointer
= !value
;
2810 opts
->x_flag_trapv
= 0;
2814 opts
->x_flag_ipa_icf_functions
= value
;
2815 opts
->x_flag_ipa_icf_variables
= value
;
2818 case OPT_falign_loops_
:
2819 check_alignment_argument (loc
, arg
, "loops",
2820 &opts
->x_flag_align_loops
,
2821 &opts
->x_str_align_loops
);
2824 case OPT_falign_jumps_
:
2825 check_alignment_argument (loc
, arg
, "jumps",
2826 &opts
->x_flag_align_jumps
,
2827 &opts
->x_str_align_jumps
);
2830 case OPT_falign_labels_
:
2831 check_alignment_argument (loc
, arg
, "labels",
2832 &opts
->x_flag_align_labels
,
2833 &opts
->x_str_align_labels
);
2836 case OPT_falign_functions_
:
2837 check_alignment_argument (loc
, arg
, "functions",
2838 &opts
->x_flag_align_functions
,
2839 &opts
->x_str_align_functions
);
2843 /* It is documented that we silently ignore silly values. */
2844 if (value
>= 1 && value
<= 100)
2845 dc
->tabstop
= value
;
2849 /* If the flag was handled in a standard way, assume the lack of
2850 processing here is intentional. */
2851 gcc_assert (option_flag_var (scode
, opts
));
2855 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
2860 /* Used to set the level of strict aliasing warnings in OPTS,
2861 when no level is specified (i.e., when -Wstrict-aliasing, and not
2862 -Wstrict-aliasing=level was given).
2863 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2864 and 0 otherwise. After calling this function, wstrict_aliasing will be
2865 set to the default value of -Wstrict_aliasing=level, currently 3. */
2867 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
2869 gcc_assert (onoff
== 0 || onoff
== 1);
2871 opts
->x_warn_strict_aliasing
= 3;
2873 opts
->x_warn_strict_aliasing
= 0;
2876 /* The following routines are useful in setting all the flags that
2877 -ffast-math and -fno-fast-math imply. */
2879 set_fast_math_flags (struct gcc_options
*opts
, int set
)
2881 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
2883 opts
->x_flag_unsafe_math_optimizations
= set
;
2884 set_unsafe_math_optimizations_flags (opts
, set
);
2886 if (!opts
->frontend_set_flag_finite_math_only
)
2887 opts
->x_flag_finite_math_only
= set
;
2888 if (!opts
->frontend_set_flag_errno_math
)
2889 opts
->x_flag_errno_math
= !set
;
2892 if (opts
->frontend_set_flag_excess_precision
== EXCESS_PRECISION_DEFAULT
)
2893 opts
->x_flag_excess_precision
2894 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
2895 if (!opts
->frontend_set_flag_signaling_nans
)
2896 opts
->x_flag_signaling_nans
= 0;
2897 if (!opts
->frontend_set_flag_rounding_math
)
2898 opts
->x_flag_rounding_math
= 0;
2899 if (!opts
->frontend_set_flag_cx_limited_range
)
2900 opts
->x_flag_cx_limited_range
= 1;
2904 /* When -funsafe-math-optimizations is set the following
2905 flags are set as well. */
2907 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
2909 if (!opts
->frontend_set_flag_trapping_math
)
2910 opts
->x_flag_trapping_math
= !set
;
2911 if (!opts
->frontend_set_flag_signed_zeros
)
2912 opts
->x_flag_signed_zeros
= !set
;
2913 if (!opts
->frontend_set_flag_associative_math
)
2914 opts
->x_flag_associative_math
= set
;
2915 if (!opts
->frontend_set_flag_reciprocal_math
)
2916 opts
->x_flag_reciprocal_math
= set
;
2919 /* Return true iff flags in OPTS are set as if -ffast-math. */
2921 fast_math_flags_set_p (const struct gcc_options
*opts
)
2923 return (!opts
->x_flag_trapping_math
2924 && opts
->x_flag_unsafe_math_optimizations
2925 && opts
->x_flag_finite_math_only
2926 && !opts
->x_flag_signed_zeros
2927 && !opts
->x_flag_errno_math
2928 && opts
->x_flag_excess_precision
== EXCESS_PRECISION_FAST
);
2931 /* Return true iff flags are set as if -ffast-math but using the flags stored
2932 in the struct cl_optimization structure. */
2934 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
2936 return (!opt
->x_flag_trapping_math
2937 && opt
->x_flag_unsafe_math_optimizations
2938 && opt
->x_flag_finite_math_only
2939 && !opt
->x_flag_signed_zeros
2940 && !opt
->x_flag_errno_math
);
2943 /* Handle a debug output -g switch for options OPTS
2944 (OPTS_SET->x_write_symbols storing whether a debug type was passed
2945 explicitly), location LOC. EXTENDED is true or false to support
2946 extended output (2 is special and means "-ggdb" was given). */
2948 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
,
2949 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2952 opts
->x_use_gnu_debug_info_extensions
= extended
;
2954 if (type
== NO_DEBUG
)
2956 if (opts
->x_write_symbols
== NO_DEBUG
)
2958 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
2962 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
2963 opts
->x_write_symbols
= DWARF2_DEBUG
;
2964 #elif defined DBX_DEBUGGING_INFO
2965 opts
->x_write_symbols
= DBX_DEBUG
;
2969 if (opts
->x_write_symbols
== NO_DEBUG
)
2970 warning_at (loc
, 0, "target system does not support debug output");
2975 /* Does it conflict with an already selected type? */
2976 if (opts_set
->x_write_symbols
!= NO_DEBUG
2977 && opts
->x_write_symbols
!= NO_DEBUG
2978 && type
!= opts
->x_write_symbols
)
2979 error_at (loc
, "debug format %qs conflicts with prior selection",
2980 debug_type_names
[type
]);
2981 opts
->x_write_symbols
= type
;
2982 opts_set
->x_write_symbols
= type
;
2985 /* A debug flag without a level defaults to level 2.
2986 If off or at level 1, set it to level 2, but if already
2987 at level 3, don't lower it. */
2990 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
2991 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
2995 int argval
= integral_argument (arg
);
2997 error_at (loc
, "unrecognized debug output level %qs", arg
);
2998 else if (argval
> 3)
2999 error_at (loc
, "debug output level %qs is too high", arg
);
3001 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
3005 /* Arrange to dump core on error for diagnostic context DC. (The
3006 regular error message is still printed first, except in the case of
3010 setup_core_dumping (diagnostic_context
*dc
)
3013 signal (SIGABRT
, SIG_DFL
);
3015 #if defined(HAVE_SETRLIMIT)
3018 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
3019 fatal_error (input_location
, "getting core file size maximum limit: %m");
3020 rlim
.rlim_cur
= rlim
.rlim_max
;
3021 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
3022 fatal_error (input_location
,
3023 "setting core file size limit to maximum: %m");
3026 diagnostic_abort_on_error (dc
);
3029 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
3030 diagnostic context DC. */
3033 decode_d_option (const char *arg
, struct gcc_options
*opts
,
3034 location_t loc
, diagnostic_context
*dc
)
3042 opts
->x_flag_debug_asm
= 1;
3045 opts
->x_flag_print_asm_name
= 1;
3048 opts
->x_flag_dump_rtl_in_asm
= 1;
3049 opts
->x_flag_print_asm_name
= 1;
3052 opts
->x_rtl_dump_and_exit
= 1;
3054 case 'D': /* These are handled by the preprocessor. */
3061 setup_core_dumping (dc
);
3064 opts
->x_flag_dump_all_passed
= true;
3068 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
3073 /* Enable (or disable if VALUE is 0) a warning option ARG (language
3074 mask LANG_MASK, option handlers HANDLERS) as an error for option
3075 structures OPTS and OPTS_SET, diagnostic context DC (possibly
3076 NULL), location LOC. This is used by -Werror=. */
3079 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
3080 const struct cl_option_handlers
*handlers
,
3081 struct gcc_options
*opts
,
3082 struct gcc_options
*opts_set
,
3083 location_t loc
, diagnostic_context
*dc
)
3088 new_option
= XNEWVEC (char, strlen (arg
) + 2);
3089 new_option
[0] = 'W';
3090 strcpy (new_option
+ 1, arg
);
3091 option_index
= find_opt (new_option
, lang_mask
);
3092 if (option_index
== OPT_SPECIAL_unknown
)
3095 const char *hint
= op
.suggest_option (new_option
);
3097 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>;"
3098 " did you mean %<-%s%>?", value
? "" : "no-",
3099 arg
, new_option
, hint
);
3101 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>",
3102 value
? "" : "no-", arg
, new_option
);
3104 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
3105 error_at (loc
, "%<-Werror=%s%>: %<-%s%> is not an option that "
3106 "controls warnings", arg
, new_option
);
3109 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
3110 const char *arg
= NULL
;
3112 if (cl_options
[option_index
].flags
& CL_JOINED
)
3113 arg
= new_option
+ cl_options
[option_index
].opt_len
;
3114 control_warning_option (option_index
, (int) kind
, arg
, value
,
3116 handlers
, opts
, opts_set
, dc
);
3121 /* Return malloced memory for the name of the option OPTION_INDEX
3122 which enabled a diagnostic (context CONTEXT), originally of type
3123 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
3127 option_name (diagnostic_context
*context
, int option_index
,
3128 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
3132 /* A warning classified as an error. */
3133 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
3134 && diag_kind
== DK_ERROR
)
3135 return concat (cl_options
[OPT_Werror_
].opt_text
,
3136 /* Skip over "-W". */
3137 cl_options
[option_index
].opt_text
+ 2,
3139 /* A warning with option. */
3141 return xstrdup (cl_options
[option_index
].opt_text
);
3143 /* A warning without option classified as an error. */
3144 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
3145 || diag_kind
== DK_WARNING
)
3146 && context
->warning_as_error_requested
)
3147 return xstrdup (cl_options
[OPT_Werror
].opt_text
);
3152 /* Get the page within the documentation for this option. */
3155 get_option_html_page (int option_index
)
3157 const cl_option
*cl_opt
= &cl_options
[option_index
];
3159 /* Analyzer options are on their own page. */
3160 if (strstr(cl_opt
->opt_text
, "analyzer-"))
3161 return "gcc/Static-Analyzer-Options.html";
3164 if ((cl_opt
->flags
& CL_Fortran
) != 0
3165 /* If it is option common to both C/C++ and Fortran, it is documented
3166 in gcc/ rather than gfortran/ docs. */
3167 && (cl_opt
->flags
& CL_C
) == 0
3169 && (cl_opt
->flags
& CL_CXX
) == 0
3172 return "gfortran/Error-and-Warning-Options.html";
3175 return "gcc/Warning-Options.html";
3178 /* Return malloced memory for a URL describing the option OPTION_INDEX
3179 which enabled a diagnostic (context CONTEXT). */
3182 get_option_url (diagnostic_context
*, int option_index
)
3185 return concat (/* DOCUMENTATION_ROOT_URL should be supplied via -D by
3186 the Makefile (see --with-documentation-root-url), and
3187 should have a trailing slash. */
3188 DOCUMENTATION_ROOT_URL
,
3190 /* get_option_html_page will return something like
3191 "gcc/Warning-Options.html". */
3192 get_option_html_page (option_index
),
3194 /* Expect an anchor of the form "index-Wfoo" e.g.
3195 <a name="index-Wformat"></a>, and thus an id within
3196 the URL of "#index-Wformat". */
3197 "#index", cl_options
[option_index
].opt_text
,
3205 namespace selftest
{
3207 /* Verify that get_option_html_page works as expected. */
3210 test_get_option_html_page ()
3212 ASSERT_STREQ (get_option_html_page (OPT_Wcpp
), "gcc/Warning-Options.html");
3213 ASSERT_STREQ (get_option_html_page (OPT_Wanalyzer_double_free
),
3214 "gcc/Static-Analyzer-Options.html");
3216 ASSERT_STREQ (get_option_html_page (OPT_Wline_truncation
),
3217 "gfortran/Error-and-Warning-Options.html");
3221 /* Run all of the selftests within this file. */
3226 test_get_option_html_page ();
3229 } // namespace selftest
3231 #endif /* #if CHECKING_P */