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
)
692 "%<-fipa-cp-clone%> is incompatible with "
693 "%<-flive-patching=inline-only-static%>");
695 opts
->x_flag_ipa_cp_clone
= 0;
697 if (opts_set
->x_flag_ipa_sra
&& opts
->x_flag_ipa_sra
)
699 "%<-fipa-sra%> is incompatible with "
700 "%<-flive-patching=inline-only-static%>");
702 opts
->x_flag_ipa_sra
= 0;
704 if (opts_set
->x_flag_partial_inlining
&& opts
->x_flag_partial_inlining
)
706 "%<-fpartial-inlining%> is incompatible with "
707 "%<-flive-patching=inline-only-static%>");
709 opts
->x_flag_partial_inlining
= 0;
711 if (opts_set
->x_flag_ipa_cp
&& opts
->x_flag_ipa_cp
)
713 "%<-fipa-cp%> is incompatible with "
714 "%<-flive-patching=inline-only-static%>");
716 opts
->x_flag_ipa_cp
= 0;
719 case LIVE_PATCHING_INLINE_CLONE
:
720 /* live patching should disable whole-program optimization. */
721 if (opts_set
->x_flag_whole_program
&& opts
->x_flag_whole_program
)
723 "%<-fwhole-program%> is incompatible with "
724 "%<-flive-patching=inline-only-static|inline-clone%>");
726 opts
->x_flag_whole_program
= 0;
728 /* visibility change should be excluded by !flag_whole_program
729 && !in_lto_p && !flag_ipa_cp_clone && !flag_ipa_sra
730 && !flag_partial_inlining. */
732 if (opts_set
->x_flag_ipa_pta
&& opts
->x_flag_ipa_pta
)
734 "%<-fipa-pta%> is incompatible with "
735 "%<-flive-patching=inline-only-static|inline-clone%>");
737 opts
->x_flag_ipa_pta
= 0;
739 if (opts_set
->x_flag_ipa_reference
&& opts
->x_flag_ipa_reference
)
741 "%<-fipa-reference%> is incompatible with "
742 "%<-flive-patching=inline-only-static|inline-clone%>");
744 opts
->x_flag_ipa_reference
= 0;
746 if (opts_set
->x_flag_ipa_ra
&& opts
->x_flag_ipa_ra
)
748 "%<-fipa-ra%> is incompatible with "
749 "%<-flive-patching=inline-only-static|inline-clone%>");
751 opts
->x_flag_ipa_ra
= 0;
753 if (opts_set
->x_flag_ipa_icf
&& opts
->x_flag_ipa_icf
)
755 "%<-fipa-icf%> is incompatible with "
756 "%<-flive-patching=inline-only-static|inline-clone%>");
758 opts
->x_flag_ipa_icf
= 0;
760 if (opts_set
->x_flag_ipa_icf_functions
&& opts
->x_flag_ipa_icf_functions
)
762 "%<-fipa-icf-functions%> is incompatible with "
763 "%<-flive-patching=inline-only-static|inline-clone%>");
765 opts
->x_flag_ipa_icf_functions
= 0;
767 if (opts_set
->x_flag_ipa_icf_variables
&& opts
->x_flag_ipa_icf_variables
)
769 "%<-fipa-icf-variables%> is incompatible with "
770 "%<-flive-patching=inline-only-static|inline-clone%>");
772 opts
->x_flag_ipa_icf_variables
= 0;
774 if (opts_set
->x_flag_ipa_bit_cp
&& opts
->x_flag_ipa_bit_cp
)
776 "%<-fipa-bit-cp%> is incompatible with "
777 "%<-flive-patching=inline-only-static|inline-clone%>");
779 opts
->x_flag_ipa_bit_cp
= 0;
781 if (opts_set
->x_flag_ipa_vrp
&& opts
->x_flag_ipa_vrp
)
783 "%<-fipa-vrp%> is incompatible with "
784 "%<-flive-patching=inline-only-static|inline-clone%>");
786 opts
->x_flag_ipa_vrp
= 0;
788 if (opts_set
->x_flag_ipa_pure_const
&& opts
->x_flag_ipa_pure_const
)
790 "%<-fipa-pure-const%> is incompatible with "
791 "%<-flive-patching=inline-only-static|inline-clone%>");
793 opts
->x_flag_ipa_pure_const
= 0;
795 if (opts_set
->x_flag_ipa_modref
&& opts
->x_flag_ipa_modref
)
797 "%<-fipa-modref%> is incompatible with "
798 "%<-flive-patching=inline-only-static|inline-clone%>");
800 opts
->x_flag_ipa_modref
= 0;
802 /* FIXME: disable unreachable code removal. */
804 /* discovery of functions/variables with no address taken. */
805 if (opts_set
->x_flag_ipa_reference_addressable
806 && opts
->x_flag_ipa_reference_addressable
)
808 "%<-fipa-reference-addressable%> is incompatible with "
809 "%<-flive-patching=inline-only-static|inline-clone%>");
811 opts
->x_flag_ipa_reference_addressable
= 0;
813 /* ipa stack alignment propagation. */
814 if (opts_set
->x_flag_ipa_stack_alignment
815 && opts
->x_flag_ipa_stack_alignment
)
817 "%<-fipa-stack-alignment%> is incompatible with "
818 "%<-flive-patching=inline-only-static|inline-clone%>");
820 opts
->x_flag_ipa_stack_alignment
= 0;
827 /* --help option argument if set. */
828 vec
<const char *> help_option_arguments
;
831 /* After all options at LOC have been read into OPTS and OPTS_SET,
832 finalize settings of those options and diagnose incompatible
835 finish_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
838 enum unwind_info_type ui_except
;
840 if (opts
->x_dump_base_name
841 && ! opts
->x_dump_base_name_prefixed
)
843 const char *sep
= opts
->x_dump_base_name
;
846 if (IS_DIR_SEPARATOR (*sep
))
850 /* If dump_base_path contains subdirectories, don't prepend
852 else if (opts
->x_dump_dir_name
)
853 /* We have a DUMP_DIR_NAME, prepend that. */
854 opts
->x_dump_base_name
= opts_concat (opts
->x_dump_dir_name
,
855 opts
->x_dump_base_name
, NULL
);
857 /* It is definitely prefixed now. */
858 opts
->x_dump_base_name_prefixed
= true;
861 /* Handle related options for unit-at-a-time, toplevel-reorder, and
863 if (!opts
->x_flag_unit_at_a_time
)
865 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
866 error_at (loc
, "section anchors must be disabled when unit-at-a-time "
868 opts
->x_flag_section_anchors
= 0;
869 if (opts
->x_flag_toplevel_reorder
== 1)
870 error_at (loc
, "toplevel reorder must be disabled when unit-at-a-time "
872 opts
->x_flag_toplevel_reorder
= 0;
875 /* -fself-test depends on the state of the compiler prior to
876 compiling anything. Ideally it should be run on an empty source
877 file. However, in case we get run with actual source, assume
878 -fsyntax-only which will inhibit any compiler initialization
879 which may confuse the self tests. */
880 if (opts
->x_flag_self_test
)
881 opts
->x_flag_syntax_only
= 1;
883 if (opts
->x_flag_tm
&& opts
->x_flag_non_call_exceptions
)
884 sorry ("transactional memory is not supported with non-call exceptions");
886 /* Unless the user has asked for section anchors, we disable toplevel
887 reordering at -O0 to disable transformations that might be surprising
888 to end users and to get -fno-toplevel-reorder tested. */
889 if (!opts
->x_optimize
890 && opts
->x_flag_toplevel_reorder
== 2
891 && !(opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
))
893 opts
->x_flag_toplevel_reorder
= 0;
894 opts
->x_flag_section_anchors
= 0;
896 if (!opts
->x_flag_toplevel_reorder
)
898 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
899 error_at (loc
, "section anchors must be disabled when toplevel reorder"
901 opts
->x_flag_section_anchors
= 0;
904 if (!opts
->x_flag_opts_finished
)
906 /* We initialize opts->x_flag_pie to -1 so that targets can set a
908 if (opts
->x_flag_pie
== -1)
910 /* We initialize opts->x_flag_pic to -1 so that we can tell if
911 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
912 if (opts
->x_flag_pic
== -1)
913 opts
->x_flag_pie
= DEFAULT_FLAG_PIE
;
915 opts
->x_flag_pie
= 0;
917 /* If -fPIE or -fpie is used, turn on PIC. */
918 if (opts
->x_flag_pie
)
919 opts
->x_flag_pic
= opts
->x_flag_pie
;
920 else if (opts
->x_flag_pic
== -1)
921 opts
->x_flag_pic
= 0;
922 if (opts
->x_flag_pic
&& !opts
->x_flag_pie
)
923 opts
->x_flag_shlib
= 1;
924 opts
->x_flag_opts_finished
= true;
927 /* We initialize opts->x_flag_stack_protect to -1 so that targets
928 can set a default value. */
929 if (opts
->x_flag_stack_protect
== -1)
930 opts
->x_flag_stack_protect
= DEFAULT_FLAG_SSP
;
932 if (opts
->x_optimize
== 0)
934 /* Inlining does not work if not optimizing,
935 so force it not to be done. */
936 opts
->x_warn_inline
= 0;
937 opts
->x_flag_no_inline
= 1;
940 /* The optimization to partition hot and cold basic blocks into separate
941 sections of the .o and executable files does not work (currently)
942 with exception handling. This is because there is no support for
943 generating unwind info. If opts->x_flag_exceptions is turned on
944 we need to turn off the partitioning optimization. */
946 ui_except
= targetm_common
.except_unwind_info (opts
);
948 if (opts
->x_flag_exceptions
949 && opts
->x_flag_reorder_blocks_and_partition
950 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
952 if (opts_set
->x_flag_reorder_blocks_and_partition
)
954 "%<-freorder-blocks-and-partition%> does not work "
955 "with exceptions on this architecture");
956 opts
->x_flag_reorder_blocks_and_partition
= 0;
957 opts
->x_flag_reorder_blocks
= 1;
960 /* If user requested unwind info, then turn off the partitioning
963 if (opts
->x_flag_unwind_tables
964 && !targetm_common
.unwind_tables_default
965 && opts
->x_flag_reorder_blocks_and_partition
966 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
968 if (opts_set
->x_flag_reorder_blocks_and_partition
)
970 "%<-freorder-blocks-and-partition%> does not support "
971 "unwind info on this architecture");
972 opts
->x_flag_reorder_blocks_and_partition
= 0;
973 opts
->x_flag_reorder_blocks
= 1;
976 /* If the target requested unwind info, then turn off the partitioning
977 optimization with a different message. Likewise, if the target does not
978 support named sections. */
980 if (opts
->x_flag_reorder_blocks_and_partition
981 && (!targetm_common
.have_named_sections
982 || (opts
->x_flag_unwind_tables
983 && targetm_common
.unwind_tables_default
984 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
986 if (opts_set
->x_flag_reorder_blocks_and_partition
)
988 "%<-freorder-blocks-and-partition%> does not work "
989 "on this architecture");
990 opts
->x_flag_reorder_blocks_and_partition
= 0;
991 opts
->x_flag_reorder_blocks
= 1;
995 /* Pipelining of outer loops is only possible when general pipelining
996 capabilities are requested. */
997 if (!opts
->x_flag_sel_sched_pipelining
)
998 opts
->x_flag_sel_sched_pipelining_outer_loops
= 0;
1000 if (opts
->x_flag_conserve_stack
)
1002 SET_OPTION_IF_UNSET (opts
, opts_set
, param_large_stack_frame
, 100);
1003 SET_OPTION_IF_UNSET (opts
, opts_set
, param_stack_frame_growth
, 40);
1006 if (opts
->x_flag_lto
)
1009 opts
->x_flag_generate_lto
= 1;
1011 /* When generating IL, do not operate in whole-program mode.
1012 Otherwise, symbols will be privatized too early, causing link
1014 opts
->x_flag_whole_program
= 0;
1016 error_at (loc
, "LTO support has not been enabled in this configuration");
1018 if (!opts
->x_flag_fat_lto_objects
1019 && (!HAVE_LTO_PLUGIN
1020 || (opts_set
->x_flag_use_linker_plugin
1021 && !opts
->x_flag_use_linker_plugin
)))
1023 if (opts_set
->x_flag_fat_lto_objects
)
1024 error_at (loc
, "%<-fno-fat-lto-objects%> are supported only with "
1026 opts
->x_flag_fat_lto_objects
= 1;
1029 /* -gsplit-dwarf isn't compatible with LTO, see PR88389. */
1030 if (opts
->x_dwarf_split_debug_info
)
1032 inform (loc
, "%<-gsplit-dwarf%> is not supported with LTO,"
1034 opts
->x_dwarf_split_debug_info
= 0;
1038 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
1039 default value if they choose based on other options. */
1040 if (opts
->x_flag_split_stack
== -1)
1041 opts
->x_flag_split_stack
= 0;
1042 else if (opts
->x_flag_split_stack
)
1044 if (!targetm_common
.supports_split_stack (true, opts
))
1046 error_at (loc
, "%<-fsplit-stack%> is not supported by "
1047 "this compiler configuration");
1048 opts
->x_flag_split_stack
= 0;
1052 /* If stack splitting is turned on, and the user did not explicitly
1053 request function partitioning, turn off partitioning, as it
1054 confuses the linker when trying to handle partitioned split-stack
1055 code that calls a non-split-stack functions. But if partitioning
1056 was turned on explicitly just hope for the best. */
1057 if (opts
->x_flag_split_stack
1058 && opts
->x_flag_reorder_blocks_and_partition
)
1059 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_reorder_blocks_and_partition
, 0);
1061 if (opts
->x_flag_reorder_blocks_and_partition
)
1062 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_reorder_functions
, 1);
1064 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
1065 if (opts
->x_dwarf_split_debug_info
)
1066 opts
->x_debug_generate_pub_sections
= 2;
1068 if ((opts
->x_flag_sanitize
1069 & (SANITIZE_USER_ADDRESS
| SANITIZE_KERNEL_ADDRESS
)) == 0)
1071 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_COMPARE
)
1073 "%<-fsanitize=pointer-compare%> must be combined with "
1074 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1075 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_SUBTRACT
)
1077 "%<-fsanitize=pointer-subtract%> must be combined with "
1078 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1081 /* Userspace and kernel ASan conflict with each other. */
1082 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
1083 && (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
))
1085 "%<-fsanitize=address%> is incompatible with "
1086 "%<-fsanitize=kernel-address%>");
1088 /* And with TSan. */
1089 if ((opts
->x_flag_sanitize
& SANITIZE_ADDRESS
)
1090 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
1092 "%<-fsanitize=address%> and %<-fsanitize=kernel-address%> "
1093 "are incompatible with %<-fsanitize=thread%>");
1095 if ((opts
->x_flag_sanitize
& SANITIZE_LEAK
)
1096 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
1098 "%<-fsanitize=leak%> is incompatible with %<-fsanitize=thread%>");
1100 /* Check error recovery for -fsanitize-recover option. */
1101 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1102 if ((opts
->x_flag_sanitize_recover
& sanitizer_opts
[i
].flag
)
1103 && !sanitizer_opts
[i
].can_recover
)
1104 error_at (loc
, "%<-fsanitize-recover=%s%> is not supported",
1105 sanitizer_opts
[i
].name
);
1107 /* When instrumenting the pointers, we don't want to remove
1108 the null pointer checks. */
1109 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
1110 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
1111 opts
->x_flag_delete_null_pointer_checks
= 0;
1113 /* Aggressive compiler optimizations may cause false negatives. */
1114 if (opts
->x_flag_sanitize
& ~(SANITIZE_LEAK
| SANITIZE_UNREACHABLE
))
1115 opts
->x_flag_aggressive_loop_optimizations
= 0;
1117 /* Enable -fsanitize-address-use-after-scope if address sanitizer is
1119 if (opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
1120 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_sanitize_address_use_after_scope
,
1123 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1125 if (opts
->x_flag_sanitize_address_use_after_scope
)
1127 if (opts
->x_flag_stack_reuse
!= SR_NONE
1128 && opts_set
->x_flag_stack_reuse
!= SR_NONE
)
1130 "%<-fsanitize-address-use-after-scope%> requires "
1131 "%<-fstack-reuse=none%> option");
1133 opts
->x_flag_stack_reuse
= SR_NONE
;
1136 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
) && opts
->x_flag_tm
)
1137 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1139 if ((opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) && opts
->x_flag_tm
)
1140 sorry ("transactional memory is not supported with "
1141 "%<-fsanitize=kernel-address%>");
1143 /* Currently live patching is not support for LTO. */
1144 if (opts
->x_flag_live_patching
&& opts
->x_flag_lto
)
1145 sorry ("live patching is not supported with LTO");
1147 /* Currently vtable verification is not supported for LTO */
1148 if (opts
->x_flag_vtable_verify
&& opts
->x_flag_lto
)
1149 sorry ("vtable verification is not supported with LTO");
1151 /* Control IPA optimizations based on different -flive-patching level. */
1152 if (opts
->x_flag_live_patching
)
1153 control_options_for_live_patching (opts
, opts_set
,
1154 opts
->x_flag_live_patching
,
1157 /* Unrolling all loops implies that standard loop unrolling must also
1159 if (opts
->x_flag_unroll_all_loops
)
1160 opts
->x_flag_unroll_loops
= 1;
1162 /* Allow cunroll to grow size accordingly. */
1163 if (!opts_set
->x_flag_cunroll_grow_size
)
1164 opts
->x_flag_cunroll_grow_size
1165 = (opts
->x_flag_unroll_loops
1166 || opts
->x_flag_peel_loops
1167 || opts
->x_optimize
>= 3);
1170 #define LEFT_COLUMN 27
1172 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1173 followed by word-wrapped HELP in a second column. */
1175 wrap_help (const char *help
,
1177 unsigned int item_width
,
1178 unsigned int columns
)
1180 unsigned int col_width
= LEFT_COLUMN
;
1181 unsigned int remaining
, room
, len
;
1183 remaining
= strlen (help
);
1187 room
= columns
- 3 - MAX (col_width
, item_width
);
1196 for (i
= 0; help
[i
]; i
++)
1198 if (i
>= room
&& len
!= remaining
)
1202 else if ((help
[i
] == '-' || help
[i
] == '/')
1203 && help
[i
+ 1] != ' '
1204 && i
> 0 && ISALPHA (help
[i
- 1]))
1209 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1211 while (help
[len
] == ' ')
1219 /* Data structure used to print list of valid option values. */
1221 class option_help_tuple
1224 option_help_tuple (int code
, vec
<const char *> values
):
1225 m_code (code
), m_values (values
)
1228 /* Code of an option. */
1231 /* List of possible values. */
1232 vec
<const char *> m_values
;
1235 /* Print help for a specific front-end, etc. */
1237 print_filtered_help (unsigned int include_flags
,
1238 unsigned int exclude_flags
,
1239 unsigned int any_flags
,
1240 unsigned int columns
,
1241 struct gcc_options
*opts
,
1242 unsigned int lang_mask
)
1247 bool displayed
= false;
1250 if (!opts
->x_help_printed
)
1251 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1253 if (!opts
->x_help_enum_printed
)
1254 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1256 auto_vec
<option_help_tuple
> help_tuples
;
1258 for (i
= 0; i
< cl_options_count
; i
++)
1260 const struct cl_option
*option
= cl_options
+ i
;
1265 if (include_flags
== 0
1266 || ((option
->flags
& include_flags
) != include_flags
))
1268 if ((option
->flags
& any_flags
) == 0)
1272 /* Skip unwanted switches. */
1273 if ((option
->flags
& exclude_flags
) != 0)
1276 /* The driver currently prints its own help text. */
1277 if ((option
->flags
& CL_DRIVER
) != 0
1278 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1279 | CL_COMMON
| CL_TARGET
)) == 0)
1282 /* If an option contains a language specification,
1283 exclude it from common unless all languages are present. */
1284 if ((include_flags
& CL_COMMON
)
1285 && !(option
->flags
& CL_DRIVER
)
1286 && (option
->flags
& CL_LANG_ALL
)
1287 && (option
->flags
& CL_LANG_ALL
) != CL_LANG_ALL
)
1291 /* Skip switches that have already been printed. */
1292 if (opts
->x_help_printed
[i
])
1295 opts
->x_help_printed
[i
] = true;
1297 help
= option
->help
;
1300 if (exclude_flags
& CL_UNDOCUMENTED
)
1303 help
= undocumented_msg
;
1306 /* Get the translation. */
1309 if (option
->alias_target
< N_OPTS
1310 && cl_options
[option
->alias_target
].help
)
1312 const struct cl_option
*target
= cl_options
+ option
->alias_target
;
1313 if (option
->help
== NULL
)
1315 /* The option is undocumented but is an alias for an option that
1316 is documented. If the option has alias arguments, then its
1317 purpose is to provide certain arguments to the other option, so
1318 inform the reader of this. Otherwise, point the reader to the
1319 other option in preference to the former. */
1321 if (option
->alias_arg
)
1323 if (option
->neg_alias_arg
)
1324 snprintf (new_help
, sizeof new_help
,
1325 _("Same as %s%s (or, in negated form, %s%s)."),
1326 target
->opt_text
, option
->alias_arg
,
1327 target
->opt_text
, option
->neg_alias_arg
);
1329 snprintf (new_help
, sizeof new_help
,
1331 target
->opt_text
, option
->alias_arg
);
1334 snprintf (new_help
, sizeof new_help
,
1340 /* For documented options with aliases, mention the aliased
1341 option's name for reference. */
1342 snprintf (new_help
, sizeof new_help
,
1343 _("%s Same as %s."),
1344 help
, cl_options
[option
->alias_target
].opt_text
);
1350 if (option
->warn_message
)
1352 /* Mention that the use of the option will trigger a warning. */
1353 if (help
== new_help
)
1354 snprintf (new_help
+ strlen (new_help
),
1355 sizeof new_help
- strlen (new_help
),
1356 " %s", _(use_diagnosed_msg
));
1358 snprintf (new_help
, sizeof new_help
,
1359 "%s %s", help
, _(use_diagnosed_msg
));
1364 /* Find the gap between the name of the
1365 option and its descriptive text. */
1366 tab
= strchr (help
, '\t');
1375 opt
= option
->opt_text
;
1379 /* With the -Q option enabled we change the descriptive text associated
1380 with an option to be an indication of its current setting. */
1381 if (!opts
->x_quiet_flag
)
1383 void *flag_var
= option_flag_var (i
, opts
);
1385 if (len
< (LEFT_COLUMN
+ 2))
1386 strcpy (new_help
, "\t\t");
1388 strcpy (new_help
, "\t");
1390 /* Set to print whether the option is enabled or disabled,
1391 or, if it's an alias for another option, the name of
1392 the aliased option. */
1393 bool print_state
= false;
1395 if (flag_var
!= NULL
1396 && option
->var_type
!= CLVC_DEFER
)
1398 /* If OPTION is only available for a specific subset
1399 of languages other than this one, mention them. */
1400 bool avail_for_lang
= true;
1401 if (unsigned langset
= option
->flags
& CL_LANG_ALL
)
1403 if (!(langset
& lang_mask
))
1405 avail_for_lang
= false;
1406 strcat (new_help
, _("[available in "));
1407 for (unsigned i
= 0, n
= 0; (1U << i
) < CL_LANG_ALL
; ++i
)
1408 if (langset
& (1U << i
))
1411 strcat (new_help
, ", ");
1412 strcat (new_help
, lang_names
[i
]);
1414 strcat (new_help
, "]");
1417 if (!avail_for_lang
)
1418 ; /* Print nothing else if the option is not available
1419 in the current language. */
1420 else if (option
->flags
& CL_JOINED
)
1422 if (option
->var_type
== CLVC_STRING
)
1424 if (* (const char **) flag_var
!= NULL
)
1425 snprintf (new_help
+ strlen (new_help
),
1426 sizeof (new_help
) - strlen (new_help
),
1427 "%s", * (const char **) flag_var
);
1429 else if (option
->var_type
== CLVC_ENUM
)
1431 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1433 const char *arg
= NULL
;
1435 value
= e
->get (flag_var
);
1436 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1438 arg
= _("[default]");
1439 snprintf (new_help
+ strlen (new_help
),
1440 sizeof (new_help
) - strlen (new_help
),
1445 if (option
->cl_host_wide_int
)
1446 sprintf (new_help
+ strlen (new_help
),
1447 _("%llu bytes"), (unsigned long long)
1448 *(unsigned HOST_WIDE_INT
*) flag_var
);
1450 sprintf (new_help
+ strlen (new_help
),
1451 "%i", * (int *) flag_var
);
1458 /* When there is no argument, print the option state only
1459 if the option takes no argument. */
1460 print_state
= !(option
->flags
& CL_JOINED
);
1464 if (option
->alias_target
< N_OPTS
1465 && option
->alias_target
!= OPT_SPECIAL_warn_removed
1466 && option
->alias_target
!= OPT_SPECIAL_ignore
1467 && option
->alias_target
!= OPT_SPECIAL_input_file
1468 && option
->alias_target
!= OPT_SPECIAL_program_name
1469 && option
->alias_target
!= OPT_SPECIAL_unknown
)
1471 const struct cl_option
*target
1472 = &cl_options
[option
->alias_target
];
1473 sprintf (new_help
+ strlen (new_help
), "%s%s",
1475 option
->alias_arg
? option
->alias_arg
: "");
1477 else if (option
->alias_target
== OPT_SPECIAL_ignore
)
1478 strcat (new_help
, ("[ignored]"));
1481 /* Print the state for an on/off option. */
1482 int ena
= option_enabled (i
, lang_mask
, opts
);
1484 strcat (new_help
, _("[enabled]"));
1486 strcat (new_help
, _("[disabled]"));
1493 if (option
->range_max
!= -1)
1496 snprintf (b
, sizeof (b
), "<%d,%d>", option
->range_min
,
1498 opt
= concat (opt
, b
, NULL
);
1502 wrap_help (help
, opt
, len
, columns
);
1505 if (option
->var_type
== CLVC_ENUM
1506 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1507 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1510 vec
<const char *> option_values
1511 = targetm_common
.get_valid_option_values (i
, NULL
);
1512 if (!option_values
.is_empty ())
1513 help_tuples
.safe_push (option_help_tuple (i
, option_values
));
1519 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1522 printf (_(" No options with the desired characteristics were found\n"));
1527 /* PR 31349: Tell the user how to see all of the
1528 options supported by a specific front end. */
1529 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1530 if ((1U << i
) & langs
)
1531 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1532 lang_names
[i
], lang_names
[i
]);
1536 else if (! displayed
)
1537 printf (_(" All options with the desired characteristics have already been displayed\n"));
1541 /* Print details of enumerated option arguments, if those
1542 enumerations have help text headings provided. If no help text
1543 is provided, presume that the possible values are listed in the
1544 help text for the relevant options. */
1545 for (i
= 0; i
< cl_enums_count
; i
++)
1547 unsigned int j
, pos
;
1549 if (opts
->x_help_enum_printed
[i
] != 1)
1551 if (cl_enums
[i
].help
== NULL
)
1553 printf (" %s\n ", _(cl_enums
[i
].help
));
1555 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1557 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1559 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1561 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1571 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1576 opts
->x_help_enum_printed
[i
] = 2;
1579 for (unsigned i
= 0; i
< help_tuples
.length (); i
++)
1581 const struct cl_option
*option
= cl_options
+ help_tuples
[i
].m_code
;
1582 printf (_(" Known valid arguments for %s option:\n "),
1584 for (unsigned j
= 0; j
< help_tuples
[i
].m_values
.length (); j
++)
1585 printf (" %s", help_tuples
[i
].m_values
[j
]);
1590 /* Display help for a specified type of option.
1591 The options must have ALL of the INCLUDE_FLAGS set
1592 ANY of the flags in the ANY_FLAGS set
1593 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1594 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1596 print_specific_help (unsigned int include_flags
,
1597 unsigned int exclude_flags
,
1598 unsigned int any_flags
,
1599 struct gcc_options
*opts
,
1600 unsigned int lang_mask
)
1602 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1603 const char * description
= NULL
;
1604 const char * descrip_extra
= "";
1608 /* Sanity check: Make sure that we do not have more
1609 languages than we have bits available to enumerate them. */
1610 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1612 /* If we have not done so already, obtain
1613 the desired maximum width of the output. */
1614 if (opts
->x_help_columns
== 0)
1616 opts
->x_help_columns
= get_terminal_width ();
1617 if (opts
->x_help_columns
== INT_MAX
)
1618 /* Use a reasonable default. */
1619 opts
->x_help_columns
= 80;
1622 /* Decide upon the title for the options that we are going to display. */
1623 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1625 switch (flag
& include_flags
)
1632 description
= _("The following options are target specific");
1635 description
= _("The following options control compiler warning messages");
1637 case CL_OPTIMIZATION
:
1638 description
= _("The following options control optimizations");
1641 description
= _("The following options are language-independent");
1644 description
= _("The following options control parameters");
1647 if (i
>= cl_lang_count
)
1649 if (exclude_flags
& all_langs_mask
)
1650 description
= _("The following options are specific to just the language ");
1652 description
= _("The following options are supported by the language ");
1653 descrip_extra
= lang_names
[i
];
1658 if (description
== NULL
)
1662 if (include_flags
& CL_UNDOCUMENTED
)
1663 description
= _("The following options are not documented");
1664 else if (include_flags
& CL_SEPARATE
)
1665 description
= _("The following options take separate arguments");
1666 else if (include_flags
& CL_JOINED
)
1667 description
= _("The following options take joined arguments");
1670 internal_error ("unrecognized %<include_flags 0x%x%> passed "
1671 "to %<print_specific_help%>",
1678 if (any_flags
& all_langs_mask
)
1679 description
= _("The following options are language-related");
1681 description
= _("The following options are language-independent");
1685 printf ("%s%s:\n", description
, descrip_extra
);
1686 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
1687 opts
->x_help_columns
, opts
, lang_mask
);
1690 /* Enable FDO-related flags. */
1693 enable_fdo_optimizations (struct gcc_options
*opts
,
1694 struct gcc_options
*opts_set
,
1697 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_branch_probabilities
, value
);
1698 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
1699 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_loops
, value
);
1700 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_peel_loops
, value
);
1701 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tracer
, value
);
1702 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_value_profile_transformations
,
1704 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
1705 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp
, value
);
1708 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp_clone
, 1);
1709 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, 1);
1711 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_predictive_commoning
, value
);
1712 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_split_loops
, value
);
1713 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unswitch_loops
, value
);
1714 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_gcse_after_reload
, value
);
1715 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_vectorize
, value
);
1716 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_slp_vectorize
, value
);
1717 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_version_loops_for_strides
, value
);
1718 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_vect_cost_model
,
1719 VECT_COST_MODEL_DYNAMIC
);
1720 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribute_patterns
,
1722 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_loop_interchange
, value
);
1723 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_jam
, value
);
1724 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribution
, value
);
1727 /* -f{,no-}sanitize{,-recover}= suboptions. */
1728 const struct sanitizer_opts_s sanitizer_opts
[] =
1730 #define SANITIZER_OPT(name, flags, recover) \
1731 { #name, flags, sizeof #name - 1, recover }
1732 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true),
1733 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
1735 SANITIZER_OPT (pointer
-compare
, SANITIZE_POINTER_COMPARE
, true),
1736 SANITIZER_OPT (pointer
-subtract
, SANITIZE_POINTER_SUBTRACT
, true),
1737 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false),
1738 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false),
1739 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true),
1740 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true),
1741 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true),
1742 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true),
1743 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true),
1744 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false),
1745 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true),
1746 SANITIZER_OPT (return, SANITIZE_RETURN
, false),
1747 SANITIZER_OPT (null
, SANITIZE_NULL
, true),
1748 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true),
1749 SANITIZER_OPT (bool, SANITIZE_BOOL
, true),
1750 SANITIZER_OPT (enum, SANITIZE_ENUM
, true),
1751 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true),
1752 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true),
1753 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true),
1754 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true),
1755 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true),
1756 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true),
1757 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
1759 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true),
1760 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true),
1761 SANITIZER_OPT (pointer
-overflow
, SANITIZE_POINTER_OVERFLOW
, true),
1762 SANITIZER_OPT (builtin
, SANITIZE_BUILTIN
, true),
1763 SANITIZER_OPT (all
, ~0U, true),
1764 #undef SANITIZER_OPT
1765 { NULL
, 0U, 0UL, false }
1768 /* -f{,no-}sanitize-coverage= suboptions. */
1769 const struct sanitizer_opts_s coverage_sanitizer_opts
[] =
1771 #define COVERAGE_SANITIZER_OPT(name, flags) \
1772 { #name, flags, sizeof #name - 1, true }
1773 COVERAGE_SANITIZER_OPT (trace
-pc
, SANITIZE_COV_TRACE_PC
),
1774 COVERAGE_SANITIZER_OPT (trace
-cmp
, SANITIZE_COV_TRACE_CMP
),
1775 #undef COVERAGE_SANITIZER_OPT
1776 { NULL
, 0U, 0UL, false }
1779 /* A struct for describing a run of chars within a string. */
1781 class string_fragment
1784 string_fragment (const char *start
, size_t len
)
1785 : m_start (start
), m_len (len
) {}
1787 const char *m_start
;
1791 /* Specialization of edit_distance_traits for string_fragment,
1792 for use by get_closest_sanitizer_option. */
1795 struct edit_distance_traits
<const string_fragment
&>
1797 static size_t get_length (const string_fragment
&fragment
)
1799 return fragment
.m_len
;
1802 static const char *get_string (const string_fragment
&fragment
)
1804 return fragment
.m_start
;
1808 /* Given ARG, an unrecognized sanitizer option, return the best
1809 matching sanitizer option, or NULL if there isn't one.
1810 OPTS is array of candidate sanitizer options.
1811 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or
1812 OPT_fsanitize_coverage_.
1813 VALUE is non-zero for the regular form of the option, zero
1814 for the "no-" form (e.g. "-fno-sanitize-recover="). */
1817 get_closest_sanitizer_option (const string_fragment
&arg
,
1818 const struct sanitizer_opts_s
*opts
,
1819 enum opt_code code
, int value
)
1821 best_match
<const string_fragment
&, const char*> bm (arg
);
1822 for (int i
= 0; opts
[i
].name
!= NULL
; ++i
)
1824 /* -fsanitize=all is not valid, so don't offer it. */
1825 if (code
== OPT_fsanitize_
1826 && opts
[i
].flag
== ~0U
1830 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
1831 don't offer the non-recoverable options. */
1832 if (code
== OPT_fsanitize_recover_
1833 && !opts
[i
].can_recover
1837 bm
.consider (opts
[i
].name
);
1839 return bm
.get_best_meaningful_candidate ();
1842 /* Parse comma separated sanitizer suboptions from P for option SCODE,
1843 adjust previous FLAGS and return new ones. If COMPLAIN is false,
1844 don't issue diagnostics. */
1847 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
1848 unsigned int flags
, int value
, bool complain
)
1850 enum opt_code code
= (enum opt_code
) scode
;
1852 const struct sanitizer_opts_s
*opts
;
1853 if (code
== OPT_fsanitize_coverage_
)
1854 opts
= coverage_sanitizer_opts
;
1856 opts
= sanitizer_opts
;
1862 const char *comma
= strchr (p
, ',');
1874 /* Check to see if the string matches an option class name. */
1875 for (i
= 0; opts
[i
].name
!= NULL
; ++i
)
1876 if (len
== opts
[i
].len
&& memcmp (p
, opts
[i
].name
, len
) == 0)
1878 /* Handle both -fsanitize and -fno-sanitize cases. */
1879 if (value
&& opts
[i
].flag
== ~0U)
1881 if (code
== OPT_fsanitize_
)
1884 error_at (loc
, "%<-fsanitize=all%> option is not valid");
1887 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
1888 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
1892 /* Do not enable -fsanitize-recover=unreachable and
1893 -fsanitize-recover=return if -fsanitize-recover=undefined
1895 if (code
== OPT_fsanitize_recover_
1896 && opts
[i
].flag
== SANITIZE_UNDEFINED
)
1897 flags
|= (SANITIZE_UNDEFINED
1898 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
1900 flags
|= opts
[i
].flag
;
1903 flags
&= ~opts
[i
].flag
;
1908 if (! found
&& complain
)
1911 = get_closest_sanitizer_option (string_fragment (p
, len
),
1915 if (code
== OPT_fsanitize_recover_
)
1916 suffix
= "-recover";
1917 else if (code
== OPT_fsanitize_coverage_
)
1918 suffix
= "-coverage";
1924 "unrecognized argument to %<-f%ssanitize%s=%> "
1925 "option: %q.*s; did you mean %qs?",
1927 suffix
, (int) len
, p
, hint
);
1930 "unrecognized argument to %<-f%ssanitize%s=%> option: "
1931 "%q.*s", value
? "" : "no-",
1932 suffix
, (int) len
, p
);
1942 /* Parse string values of no_sanitize attribute passed in VALUE.
1943 Values are separated with comma. */
1946 parse_no_sanitize_attribute (char *value
)
1948 unsigned int flags
= 0;
1950 char *q
= strtok (value
, ",");
1954 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1955 if (strcmp (sanitizer_opts
[i
].name
, q
) == 0)
1957 flags
|= sanitizer_opts
[i
].flag
;
1958 if (sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
1959 flags
|= SANITIZE_UNDEFINED_NONDEFAULT
;
1963 if (sanitizer_opts
[i
].name
== NULL
)
1964 warning (OPT_Wattributes
,
1965 "%qs attribute directive ignored", q
);
1967 q
= strtok (NULL
, ",");
1973 /* Parse -falign-NAME format for a FLAG value. Return individual
1974 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
1975 set, print error message at LOC location. */
1978 parse_and_check_align_values (const char *flag
,
1980 auto_vec
<unsigned> &result_values
,
1984 char *str
= xstrdup (flag
);
1985 for (char *p
= strtok (str
, ":"); p
; p
= strtok (NULL
, ":"))
1988 int v
= strtol (p
, &end
, 10);
1989 if (*end
!= '\0' || v
< 0)
1992 error_at (loc
, "invalid arguments for %<-falign-%s%> option: %qs",
1998 result_values
.safe_push ((unsigned)v
);
2003 /* Check that we have a correct number of values. */
2004 if (result_values
.is_empty () || result_values
.length () > 4)
2007 error_at (loc
, "invalid number of arguments for %<-falign-%s%> "
2008 "option: %qs", name
, flag
);
2012 for (unsigned i
= 0; i
< result_values
.length (); i
++)
2013 if (result_values
[i
] > MAX_CODE_ALIGN_VALUE
)
2016 error_at (loc
, "%<-falign-%s%> is not between 0 and %d",
2017 name
, MAX_CODE_ALIGN_VALUE
);
2024 /* Check that alignment value FLAG for -falign-NAME is valid at a given
2025 location LOC. OPT_STR points to the stored -falign-NAME=argument and
2026 OPT_FLAG points to the associated -falign-NAME on/off flag. */
2029 check_alignment_argument (location_t loc
, const char *flag
, const char *name
,
2030 int *opt_flag
, const char **opt_str
)
2032 auto_vec
<unsigned> align_result
;
2033 parse_and_check_align_values (flag
, name
, align_result
, true, loc
);
2035 if (align_result
.length() >= 1 && align_result
[0] == 0)
2042 /* Print help when OPT__help_ is set. */
2045 print_help (struct gcc_options
*opts
, unsigned int lang_mask
,
2046 const char *help_option_argument
)
2048 const char *a
= help_option_argument
;
2049 unsigned int include_flags
= 0;
2050 /* Note - by default we include undocumented options when listing
2051 specific classes. If you only want to see documented options
2052 then add ",^undocumented" to the --help= option. E.g.:
2054 --help=target,^undocumented */
2055 unsigned int exclude_flags
= 0;
2057 if (lang_mask
== CL_DRIVER
)
2060 /* Walk along the argument string, parsing each word in turn.
2062 arg = [^]{word}[,{arg}]
2063 word = {optimizers|target|warnings|undocumented|
2064 params|common|<language>} */
2074 { "optimizers", CL_OPTIMIZATION
},
2075 { "target", CL_TARGET
},
2076 { "warnings", CL_WARNING
},
2077 { "undocumented", CL_UNDOCUMENTED
},
2078 { "params", CL_PARAMS
},
2079 { "joined", CL_JOINED
},
2080 { "separate", CL_SEPARATE
},
2081 { "common", CL_COMMON
},
2084 unsigned int *pflags
;
2086 unsigned int lang_flag
, specific_flag
;
2095 error ("missing argument to %qs", "--help=^");
2098 pflags
= &exclude_flags
;
2101 pflags
= &include_flags
;
2103 comma
= strchr (a
, ',');
2114 /* Check to see if the string matches an option class name. */
2115 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
2116 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
2118 specific_flag
= specifics
[i
].flag
;
2122 /* Check to see if the string matches a language name.
2123 Note - we rely upon the alpha-sorted nature of the entries in
2124 the lang_names array, specifically that shorter names appear
2125 before their longer variants. (i.e. C before C++). That way
2126 when we are attempting to match --help=c for example we will
2127 match with C first and not C++. */
2128 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
2129 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
2131 lang_flag
= 1U << i
;
2135 if (specific_flag
!= 0)
2138 *pflags
|= specific_flag
;
2141 /* The option's argument matches both the start of a
2142 language name and the start of an option class name.
2143 We have a special case for when the user has
2144 specified "--help=c", but otherwise we have to issue
2146 if (strncasecmp (a
, "c", len
) == 0)
2147 *pflags
|= lang_flag
;
2150 "%<--help%> argument %q.*s is ambiguous, "
2151 "please be more specific",
2155 else if (lang_flag
!= 0)
2156 *pflags
|= lang_flag
;
2159 "unrecognized argument to %<--help=%> option: %q.*s",
2167 /* We started using PerFunction/Optimization for parameters and
2168 a warning. We should exclude these from optimization options. */
2169 if (include_flags
& CL_OPTIMIZATION
)
2170 exclude_flags
|= CL_WARNING
;
2171 if (!(include_flags
& CL_PARAMS
))
2172 exclude_flags
|= CL_PARAMS
;
2175 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
2179 /* Handle target- and language-independent options. Return zero to
2180 generate an "unknown option" message. Only options that need
2181 extra handling need to be listed here; if you simply want
2182 DECODED->value assigned to a variable, it happens automatically. */
2185 common_handle_option (struct gcc_options
*opts
,
2186 struct gcc_options
*opts_set
,
2187 const struct cl_decoded_option
*decoded
,
2188 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
2190 const struct cl_option_handlers
*handlers
,
2191 diagnostic_context
*dc
,
2192 void (*target_option_override_hook
) (void))
2194 size_t scode
= decoded
->opt_index
;
2195 const char *arg
= decoded
->arg
;
2196 HOST_WIDE_INT value
= decoded
->value
;
2197 enum opt_code code
= (enum opt_code
) scode
;
2199 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
2205 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
2206 unsigned int undoc_mask
;
2209 if (lang_mask
== CL_DRIVER
)
2212 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
2215 target_option_override_hook ();
2216 /* First display any single language specific options. */
2217 for (i
= 0; i
< cl_lang_count
; i
++)
2219 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
2221 /* Next display any multi language specific options. */
2222 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
2223 /* Then display any remaining, non-language options. */
2224 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
2226 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
2227 opts
->x_exit_after_options
= true;
2231 case OPT__target_help
:
2232 if (lang_mask
== CL_DRIVER
)
2235 target_option_override_hook ();
2236 print_specific_help (CL_TARGET
, CL_UNDOCUMENTED
, 0, opts
, lang_mask
);
2237 opts
->x_exit_after_options
= true;
2242 help_option_arguments
.safe_push (arg
);
2243 opts
->x_exit_after_options
= true;
2248 if (lang_mask
== CL_DRIVER
)
2251 opts
->x_exit_after_options
= true;
2254 case OPT__completion_
:
2257 case OPT_fsanitize_
:
2258 opts
->x_flag_sanitize
2259 = parse_sanitizer_options (arg
, loc
, code
,
2260 opts
->x_flag_sanitize
, value
, true);
2262 /* Kernel ASan implies normal ASan but does not yet support
2264 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
2266 SET_OPTION_IF_UNSET (opts
, opts_set
,
2267 param_asan_instrumentation_with_call_threshold
,
2269 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_globals
, 0);
2270 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_stack
, 0);
2271 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_protect_allocas
, 0);
2272 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_use_after_return
, 0);
2276 case OPT_fsanitize_recover_
:
2277 opts
->x_flag_sanitize_recover
2278 = parse_sanitizer_options (arg
, loc
, code
,
2279 opts
->x_flag_sanitize_recover
, value
, true);
2282 case OPT_fasan_shadow_offset_
:
2286 case OPT_fsanitize_address_use_after_scope
:
2287 opts
->x_flag_sanitize_address_use_after_scope
= value
;
2290 case OPT_fsanitize_recover
:
2292 opts
->x_flag_sanitize_recover
2293 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)
2294 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2296 opts
->x_flag_sanitize_recover
2297 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2300 case OPT_fsanitize_coverage_
:
2301 opts
->x_flag_sanitize_coverage
2302 = parse_sanitizer_options (arg
, loc
, code
,
2303 opts
->x_flag_sanitize_coverage
, value
, true);
2310 /* Currently handled in a prescan. */
2314 dc
->warning_as_error_requested
= value
;
2318 if (lang_mask
== CL_DRIVER
)
2321 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
2322 opts
, opts_set
, loc
, dc
);
2325 case OPT_Wfatal_errors
:
2326 dc
->fatal_errors
= value
;
2329 case OPT_Wstack_usage_
:
2330 opts
->x_flag_stack_usage_info
= value
!= -1;
2333 case OPT_Wstrict_aliasing
:
2334 set_Wstrict_aliasing (opts
, value
);
2337 case OPT_Wstrict_overflow
:
2338 opts
->x_warn_strict_overflow
= (value
2339 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2343 case OPT_Wsystem_headers
:
2344 dc
->dc_warn_system_headers
= value
;
2348 opts
->x_flag_gen_aux_info
= 1;
2352 decode_d_option (arg
, opts
, loc
, dc
);
2355 case OPT_fcall_used_
:
2356 case OPT_fcall_saved_
:
2364 case OPT_fdebug_prefix_map_
:
2365 case OPT_ffile_prefix_map_
:
2369 case OPT_fcallgraph_info
:
2370 opts
->x_flag_callgraph_info
= CALLGRAPH_INFO_NAKED
;
2373 case OPT_fcallgraph_info_
:
2376 my_arg
= xstrdup (arg
);
2377 p
= strtok (my_arg
, ",");
2380 if (strcmp (p
, "su") == 0)
2382 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_STACK_USAGE
;
2383 opts
->x_flag_stack_usage_info
= true;
2385 else if (strcmp (p
, "da") == 0)
2386 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_DYNAMIC_ALLOC
;
2389 p
= strtok (NULL
, ",");
2395 case OPT_fdiagnostics_show_location_
:
2396 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2399 case OPT_fdiagnostics_show_caret
:
2400 dc
->show_caret
= value
;
2403 case OPT_fdiagnostics_show_labels
:
2404 dc
->show_labels_p
= value
;
2407 case OPT_fdiagnostics_show_line_numbers
:
2408 dc
->show_line_numbers_p
= value
;
2411 case OPT_fdiagnostics_color_
:
2412 diagnostic_color_init (dc
, value
);
2415 case OPT_fdiagnostics_urls_
:
2416 diagnostic_urls_init (dc
, value
);
2419 case OPT_fdiagnostics_format_
:
2420 diagnostic_output_format_init (dc
,
2421 (enum diagnostics_output_format
)value
);
2424 case OPT_fdiagnostics_parseable_fixits
:
2425 dc
->parseable_fixits_p
= value
;
2428 case OPT_fdiagnostics_column_unit_
:
2429 dc
->column_unit
= (enum diagnostics_column_unit
)value
;
2432 case OPT_fdiagnostics_column_origin_
:
2433 dc
->column_origin
= value
;
2436 case OPT_fdiagnostics_show_cwe
:
2437 dc
->show_cwe
= value
;
2440 case OPT_fdiagnostics_path_format_
:
2441 dc
->path_format
= (enum diagnostic_path_format
)value
;
2444 case OPT_fdiagnostics_show_path_depths
:
2445 dc
->show_path_depths
= value
;
2448 case OPT_fdiagnostics_show_option
:
2449 dc
->show_option_requested
= value
;
2452 case OPT_fdiagnostics_minimum_margin_width_
:
2453 dc
->min_margin_width
= value
;
2460 case OPT_ffast_math
:
2461 set_fast_math_flags (opts
, value
);
2464 case OPT_funsafe_math_optimizations
:
2465 set_unsafe_math_optimizations_flags (opts
, value
);
2472 case OPT_finline_limit_
:
2473 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_single
,
2475 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_auto
,
2479 case OPT_finstrument_functions_exclude_function_list_
:
2480 add_comma_separated_to_vector
2481 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2484 case OPT_finstrument_functions_exclude_file_list_
:
2485 add_comma_separated_to_vector
2486 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2489 case OPT_fmessage_length_
:
2490 pp_set_line_maximum_length (dc
->printer
, value
);
2491 diagnostic_set_caret_max_width (dc
, value
);
2495 case OPT_fopt_info_
:
2503 #ifndef ACCEL_COMPILER
2504 case OPT_foffload_abi_
:
2505 error_at (loc
, "%<-foffload-abi%> option can be specified only for "
2506 "offload compiler");
2510 case OPT_fpack_struct_
:
2511 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2513 "structure alignment must be a small power of two, not %wu",
2516 opts
->x_initial_max_fld_align
= value
;
2520 case OPT_fplugin_arg_
:
2524 case OPT_fprofile_use_
:
2525 opts
->x_profile_data_prefix
= xstrdup (arg
);
2526 opts
->x_flag_profile_use
= true;
2528 /* No break here - do -fprofile-use processing. */
2530 case OPT_fprofile_use
:
2531 enable_fdo_optimizations (opts
, opts_set
, value
);
2532 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_reorder_functions
,
2534 /* Indirect call profiling should do all useful transformations
2535 speculative devirtualization does. */
2536 if (opts
->x_flag_value_profile_transformations
)
2537 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_devirtualize_speculatively
,
2541 case OPT_fauto_profile_
:
2542 opts
->x_auto_profile_file
= xstrdup (arg
);
2543 opts
->x_flag_auto_profile
= true;
2545 /* No break here - do -fauto-profile processing. */
2547 case OPT_fauto_profile
:
2548 enable_fdo_optimizations (opts
, opts_set
, value
);
2549 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_correction
, value
);
2550 SET_OPTION_IF_UNSET (opts
, opts_set
,
2551 param_early_inliner_max_iterations
, 10);
2554 case OPT_fprofile_generate_
:
2555 opts
->x_profile_data_prefix
= xstrdup (arg
);
2557 /* No break here - do -fprofile-generate processing. */
2559 case OPT_fprofile_generate
:
2560 SET_OPTION_IF_UNSET (opts
, opts_set
, profile_arc_flag
, value
);
2561 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
2562 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
2563 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, value
);
2566 case OPT_fpatchable_function_entry_
:
2568 char *patch_area_arg
= xstrdup (arg
);
2569 char *comma
= strchr (patch_area_arg
, ',');
2573 function_entry_patch_area_size
=
2574 integral_argument (patch_area_arg
);
2575 function_entry_patch_area_start
=
2576 integral_argument (comma
+ 1);
2580 function_entry_patch_area_size
=
2581 integral_argument (patch_area_arg
);
2582 function_entry_patch_area_start
= 0;
2584 if (function_entry_patch_area_size
< 0
2585 || function_entry_patch_area_size
> USHRT_MAX
2586 || function_entry_patch_area_start
< 0
2587 || function_entry_patch_area_start
> USHRT_MAX
2588 || function_entry_patch_area_size
2589 < function_entry_patch_area_start
)
2590 error ("invalid arguments for %<-fpatchable-function-entry%>");
2591 free (patch_area_arg
);
2595 case OPT_ftree_vectorize
:
2596 /* Automatically sets -ftree-loop-vectorize and
2597 -ftree-slp-vectorize. Nothing more to do here. */
2599 case OPT_fshow_column
:
2600 dc
->show_column
= value
;
2603 case OPT_frandom_seed
:
2604 /* The real switch is -fno-random-seed. */
2610 case OPT_frandom_seed_
:
2614 case OPT_fsched_verbose_
:
2615 #ifdef INSN_SCHEDULING
2616 /* Handled with Var in common.opt. */
2622 case OPT_fsched_stalled_insns_
:
2623 opts
->x_flag_sched_stalled_insns
= value
;
2624 if (opts
->x_flag_sched_stalled_insns
== 0)
2625 opts
->x_flag_sched_stalled_insns
= -1;
2628 case OPT_fsched_stalled_insns_dep_
:
2629 opts
->x_flag_sched_stalled_insns_dep
= value
;
2632 case OPT_fstack_check_
:
2633 if (!strcmp (arg
, "no"))
2634 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
2635 else if (!strcmp (arg
, "generic"))
2636 /* This is the old stack checking method. */
2637 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2638 ? FULL_BUILTIN_STACK_CHECK
2639 : GENERIC_STACK_CHECK
;
2640 else if (!strcmp (arg
, "specific"))
2641 /* This is the new stack checking method. */
2642 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2643 ? FULL_BUILTIN_STACK_CHECK
2644 : STACK_CHECK_STATIC_BUILTIN
2645 ? STATIC_BUILTIN_STACK_CHECK
2646 : GENERIC_STACK_CHECK
;
2648 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
2651 case OPT_fstack_limit
:
2652 /* The real switch is -fno-stack-limit. */
2658 case OPT_fstack_limit_register_
:
2659 case OPT_fstack_limit_symbol_
:
2663 case OPT_fstack_usage
:
2664 opts
->x_flag_stack_usage
= value
;
2665 opts
->x_flag_stack_usage_info
= value
!= 0;
2669 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
2674 if (arg
&& strlen (arg
) != 0)
2676 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
2677 "use %<-gdwarf-%s%> for DWARF version "
2678 "or %<-gdwarf%> %<-g%s%> for debug level", arg
, arg
, arg
);
2682 value
= opts
->x_dwarf_version
;
2686 if (value
< 2 || value
> 5)
2687 error_at (loc
, "dwarf version %wu is not supported", value
);
2689 opts
->x_dwarf_version
= value
;
2690 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
2694 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
2699 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
, opts
, opts_set
,
2704 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2709 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
, opts
, opts_set
,
2715 /* Handled completely via specs. */
2718 case OPT_pedantic_errors
:
2719 dc
->pedantic_errors
= 1;
2720 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
2722 handlers
, opts
, opts_set
,
2727 opts
->x_flag_lto
= value
? "" : NULL
;
2731 if (strcmp (arg
, "none") != 0
2732 && strcmp (arg
, "jobserver") != 0
2733 && strcmp (arg
, "auto") != 0
2736 "unrecognized argument to %<-flto=%> option: %qs", arg
);
2740 dc
->dc_inhibit_warnings
= true;
2743 case OPT_fmax_errors_
:
2744 dc
->max_errors
= value
;
2747 case OPT_fuse_ld_bfd
:
2748 case OPT_fuse_ld_gold
:
2749 case OPT_fuse_ld_lld
:
2750 case OPT_fuse_linker_plugin
:
2751 /* No-op. Used by the driver and passed to us because it starts with f.*/
2756 opts
->x_flag_trapv
= 0;
2761 opts
->x_flag_wrapv
= 0;
2764 case OPT_fstrict_overflow
:
2765 opts
->x_flag_wrapv
= !value
;
2766 opts
->x_flag_wrapv_pointer
= !value
;
2768 opts
->x_flag_trapv
= 0;
2772 opts
->x_flag_ipa_icf_functions
= value
;
2773 opts
->x_flag_ipa_icf_variables
= value
;
2776 case OPT_falign_loops_
:
2777 check_alignment_argument (loc
, arg
, "loops",
2778 &opts
->x_flag_align_loops
,
2779 &opts
->x_str_align_loops
);
2782 case OPT_falign_jumps_
:
2783 check_alignment_argument (loc
, arg
, "jumps",
2784 &opts
->x_flag_align_jumps
,
2785 &opts
->x_str_align_jumps
);
2788 case OPT_falign_labels_
:
2789 check_alignment_argument (loc
, arg
, "labels",
2790 &opts
->x_flag_align_labels
,
2791 &opts
->x_str_align_labels
);
2794 case OPT_falign_functions_
:
2795 check_alignment_argument (loc
, arg
, "functions",
2796 &opts
->x_flag_align_functions
,
2797 &opts
->x_str_align_functions
);
2801 /* It is documented that we silently ignore silly values. */
2802 if (value
>= 1 && value
<= 100)
2803 dc
->tabstop
= value
;
2807 /* If the flag was handled in a standard way, assume the lack of
2808 processing here is intentional. */
2809 gcc_assert (option_flag_var (scode
, opts
));
2813 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
2818 /* Used to set the level of strict aliasing warnings in OPTS,
2819 when no level is specified (i.e., when -Wstrict-aliasing, and not
2820 -Wstrict-aliasing=level was given).
2821 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2822 and 0 otherwise. After calling this function, wstrict_aliasing will be
2823 set to the default value of -Wstrict_aliasing=level, currently 3. */
2825 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
2827 gcc_assert (onoff
== 0 || onoff
== 1);
2829 opts
->x_warn_strict_aliasing
= 3;
2831 opts
->x_warn_strict_aliasing
= 0;
2834 /* The following routines are useful in setting all the flags that
2835 -ffast-math and -fno-fast-math imply. */
2837 set_fast_math_flags (struct gcc_options
*opts
, int set
)
2839 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
2841 opts
->x_flag_unsafe_math_optimizations
= set
;
2842 set_unsafe_math_optimizations_flags (opts
, set
);
2844 if (!opts
->frontend_set_flag_finite_math_only
)
2845 opts
->x_flag_finite_math_only
= set
;
2846 if (!opts
->frontend_set_flag_errno_math
)
2847 opts
->x_flag_errno_math
= !set
;
2850 if (opts
->frontend_set_flag_excess_precision
== EXCESS_PRECISION_DEFAULT
)
2851 opts
->x_flag_excess_precision
2852 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
2853 if (!opts
->frontend_set_flag_signaling_nans
)
2854 opts
->x_flag_signaling_nans
= 0;
2855 if (!opts
->frontend_set_flag_rounding_math
)
2856 opts
->x_flag_rounding_math
= 0;
2857 if (!opts
->frontend_set_flag_cx_limited_range
)
2858 opts
->x_flag_cx_limited_range
= 1;
2862 /* When -funsafe-math-optimizations is set the following
2863 flags are set as well. */
2865 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
2867 if (!opts
->frontend_set_flag_trapping_math
)
2868 opts
->x_flag_trapping_math
= !set
;
2869 if (!opts
->frontend_set_flag_signed_zeros
)
2870 opts
->x_flag_signed_zeros
= !set
;
2871 if (!opts
->frontend_set_flag_associative_math
)
2872 opts
->x_flag_associative_math
= set
;
2873 if (!opts
->frontend_set_flag_reciprocal_math
)
2874 opts
->x_flag_reciprocal_math
= set
;
2877 /* Return true iff flags in OPTS are set as if -ffast-math. */
2879 fast_math_flags_set_p (const struct gcc_options
*opts
)
2881 return (!opts
->x_flag_trapping_math
2882 && opts
->x_flag_unsafe_math_optimizations
2883 && opts
->x_flag_finite_math_only
2884 && !opts
->x_flag_signed_zeros
2885 && !opts
->x_flag_errno_math
2886 && opts
->x_flag_excess_precision
== EXCESS_PRECISION_FAST
);
2889 /* Return true iff flags are set as if -ffast-math but using the flags stored
2890 in the struct cl_optimization structure. */
2892 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
2894 return (!opt
->x_flag_trapping_math
2895 && opt
->x_flag_unsafe_math_optimizations
2896 && opt
->x_flag_finite_math_only
2897 && !opt
->x_flag_signed_zeros
2898 && !opt
->x_flag_errno_math
);
2901 /* Handle a debug output -g switch for options OPTS
2902 (OPTS_SET->x_write_symbols storing whether a debug type was passed
2903 explicitly), location LOC. EXTENDED is true or false to support
2904 extended output (2 is special and means "-ggdb" was given). */
2906 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
,
2907 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2910 opts
->x_use_gnu_debug_info_extensions
= extended
;
2912 if (type
== NO_DEBUG
)
2914 if (opts
->x_write_symbols
== NO_DEBUG
)
2916 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
2920 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
2921 opts
->x_write_symbols
= DWARF2_DEBUG
;
2922 #elif defined DBX_DEBUGGING_INFO
2923 opts
->x_write_symbols
= DBX_DEBUG
;
2927 if (opts
->x_write_symbols
== NO_DEBUG
)
2928 warning_at (loc
, 0, "target system does not support debug output");
2933 /* Does it conflict with an already selected type? */
2934 if (opts_set
->x_write_symbols
!= NO_DEBUG
2935 && opts
->x_write_symbols
!= NO_DEBUG
2936 && type
!= opts
->x_write_symbols
)
2937 error_at (loc
, "debug format %qs conflicts with prior selection",
2938 debug_type_names
[type
]);
2939 opts
->x_write_symbols
= type
;
2940 opts_set
->x_write_symbols
= type
;
2943 /* A debug flag without a level defaults to level 2.
2944 If off or at level 1, set it to level 2, but if already
2945 at level 3, don't lower it. */
2948 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
2949 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
2953 int argval
= integral_argument (arg
);
2955 error_at (loc
, "unrecognized debug output level %qs", arg
);
2956 else if (argval
> 3)
2957 error_at (loc
, "debug output level %qs is too high", arg
);
2959 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
2963 /* Arrange to dump core on error for diagnostic context DC. (The
2964 regular error message is still printed first, except in the case of
2968 setup_core_dumping (diagnostic_context
*dc
)
2971 signal (SIGABRT
, SIG_DFL
);
2973 #if defined(HAVE_SETRLIMIT)
2976 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
2977 fatal_error (input_location
, "getting core file size maximum limit: %m");
2978 rlim
.rlim_cur
= rlim
.rlim_max
;
2979 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
2980 fatal_error (input_location
,
2981 "setting core file size limit to maximum: %m");
2984 diagnostic_abort_on_error (dc
);
2987 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
2988 diagnostic context DC. */
2991 decode_d_option (const char *arg
, struct gcc_options
*opts
,
2992 location_t loc
, diagnostic_context
*dc
)
3000 opts
->x_flag_debug_asm
= 1;
3003 opts
->x_flag_print_asm_name
= 1;
3006 opts
->x_flag_dump_rtl_in_asm
= 1;
3007 opts
->x_flag_print_asm_name
= 1;
3010 opts
->x_rtl_dump_and_exit
= 1;
3012 case 'D': /* These are handled by the preprocessor. */
3019 setup_core_dumping (dc
);
3022 opts
->x_flag_dump_all_passed
= true;
3026 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
3031 /* Enable (or disable if VALUE is 0) a warning option ARG (language
3032 mask LANG_MASK, option handlers HANDLERS) as an error for option
3033 structures OPTS and OPTS_SET, diagnostic context DC (possibly
3034 NULL), location LOC. This is used by -Werror=. */
3037 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
3038 const struct cl_option_handlers
*handlers
,
3039 struct gcc_options
*opts
,
3040 struct gcc_options
*opts_set
,
3041 location_t loc
, diagnostic_context
*dc
)
3046 new_option
= XNEWVEC (char, strlen (arg
) + 2);
3047 new_option
[0] = 'W';
3048 strcpy (new_option
+ 1, arg
);
3049 option_index
= find_opt (new_option
, lang_mask
);
3050 if (option_index
== OPT_SPECIAL_unknown
)
3053 const char *hint
= op
.suggest_option (new_option
);
3055 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>;"
3056 " did you mean %<-%s%>?", value
? "" : "no-",
3057 arg
, new_option
, hint
);
3059 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>",
3060 value
? "" : "no-", arg
, new_option
);
3062 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
3063 error_at (loc
, "%<-Werror=%s%>: %<-%s%> is not an option that "
3064 "controls warnings", arg
, new_option
);
3067 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
3068 const char *arg
= NULL
;
3070 if (cl_options
[option_index
].flags
& CL_JOINED
)
3071 arg
= new_option
+ cl_options
[option_index
].opt_len
;
3072 control_warning_option (option_index
, (int) kind
, arg
, value
,
3074 handlers
, opts
, opts_set
, dc
);
3079 /* Return malloced memory for the name of the option OPTION_INDEX
3080 which enabled a diagnostic (context CONTEXT), originally of type
3081 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
3085 option_name (diagnostic_context
*context
, int option_index
,
3086 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
3090 /* A warning classified as an error. */
3091 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
3092 && diag_kind
== DK_ERROR
)
3093 return concat (cl_options
[OPT_Werror_
].opt_text
,
3094 /* Skip over "-W". */
3095 cl_options
[option_index
].opt_text
+ 2,
3097 /* A warning with option. */
3099 return xstrdup (cl_options
[option_index
].opt_text
);
3101 /* A warning without option classified as an error. */
3102 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
3103 || diag_kind
== DK_WARNING
)
3104 && context
->warning_as_error_requested
)
3105 return xstrdup (cl_options
[OPT_Werror
].opt_text
);
3110 /* Get the page within the documentation for this option. */
3113 get_option_html_page (int option_index
)
3115 const cl_option
*cl_opt
= &cl_options
[option_index
];
3117 /* Analyzer options are on their own page. */
3118 if (strstr(cl_opt
->opt_text
, "analyzer-"))
3119 return "gcc/Static-Analyzer-Options.html";
3122 if ((cl_opt
->flags
& CL_Fortran
) != 0
3123 /* If it is option common to both C/C++ and Fortran, it is documented
3124 in gcc/ rather than gfortran/ docs. */
3125 && (cl_opt
->flags
& CL_C
) == 0
3127 && (cl_opt
->flags
& CL_CXX
) == 0
3130 return "gfortran/Error-and-Warning-Options.html";
3133 return "gcc/Warning-Options.html";
3136 /* Return malloced memory for a URL describing the option OPTION_INDEX
3137 which enabled a diagnostic (context CONTEXT). */
3140 get_option_url (diagnostic_context
*, int option_index
)
3143 return concat (/* DOCUMENTATION_ROOT_URL should be supplied via -D by
3144 the Makefile (see --with-documentation-root-url), and
3145 should have a trailing slash. */
3146 DOCUMENTATION_ROOT_URL
,
3148 /* get_option_html_page will return something like
3149 "gcc/Warning-Options.html". */
3150 get_option_html_page (option_index
),
3152 /* Expect an anchor of the form "index-Wfoo" e.g.
3153 <a name="index-Wformat"></a>, and thus an id within
3154 the URL of "#index-Wformat". */
3155 "#index", cl_options
[option_index
].opt_text
,
3163 namespace selftest
{
3165 /* Verify that get_option_html_page works as expected. */
3168 test_get_option_html_page ()
3170 ASSERT_STREQ (get_option_html_page (OPT_Wcpp
), "gcc/Warning-Options.html");
3171 ASSERT_STREQ (get_option_html_page (OPT_Wanalyzer_double_free
),
3172 "gcc/Static-Analyzer-Options.html");
3174 ASSERT_STREQ (get_option_html_page (OPT_Wline_truncation
),
3175 "gfortran/Error-and-Warning-Options.html");
3179 /* Run all of the selftests within this file. */
3184 test_get_option_html_page ();
3187 } // namespace selftest
3189 #endif /* #if CHECKING_P */