1 /* Command line option handling.
2 Copyright (C) 2002-2023 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 #include "file-prefix-map.h"
39 /* In this file all option sets are explicit. */
42 /* Set by -fcanon-prefix-map. */
43 bool flag_canon_prefix_map
;
45 static void set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
);
47 /* Names of fundamental debug info formats indexed by enum
50 const char *const debug_type_names
[] =
52 "none", "stabs", "dwarf-2", "xcoff", "vms", "ctf", "btf"
55 /* Bitmasks of fundamental debug info formats indexed by enum
58 static uint32_t debug_type_masks
[] =
60 NO_DEBUG
, DWARF2_DEBUG
, VMS_DEBUG
,
64 /* Names of the set of debug formats requested by user. Updated and accessed
65 via debug_set_names. */
67 static char df_set_names
[sizeof "none stabs dwarf-2 xcoff vms ctf btf"];
69 /* Get enum debug_info_type of the specified debug format, for error messages.
70 Can be used only for individual debug format types. */
73 debug_set_to_format (uint32_t debug_info_set
)
76 enum debug_info_type dinfo_type
= DINFO_TYPE_NONE
;
77 /* Find first set bit. */
79 idx
= exact_log2 (debug_info_set
& - debug_info_set
);
80 /* Check that only one bit is set, if at all. This function is meant to be
81 used only for vanilla debug_info_set bitmask values, i.e. for individual
82 debug format types upto DINFO_TYPE_MAX. */
83 gcc_assert ((debug_info_set
& (debug_info_set
- 1)) == 0);
84 dinfo_type
= (enum debug_info_type
)idx
;
85 gcc_assert (dinfo_type
<= DINFO_TYPE_MAX
);
89 /* Get the number of debug formats enabled for output. */
92 debug_set_count (uint32_t w_symbols
)
94 unsigned int count
= 0;
98 w_symbols
&= ~ (w_symbols
& - w_symbols
);
103 /* Get the names of the debug formats enabled for output. */
106 debug_set_names (uint32_t w_symbols
)
108 uint32_t df_mask
= 0;
109 /* Reset the string to be returned. */
110 memset (df_set_names
, 0, sizeof (df_set_names
));
111 /* Get the popcount. */
112 int num_set_df
= debug_set_count (w_symbols
);
113 /* Iterate over the debug formats. Add name string for those enabled. */
114 for (int i
= DINFO_TYPE_NONE
; i
<= DINFO_TYPE_MAX
; i
++)
116 df_mask
= debug_type_masks
[i
];
117 if (w_symbols
& df_mask
)
119 strcat (df_set_names
, debug_type_names
[i
]);
122 strcat (df_set_names
, " ");
128 /* No debug formats enabled. */
129 gcc_assert (i
== DINFO_TYPE_NONE
);
130 strcat (df_set_names
, debug_type_names
[i
]);
137 /* Return TRUE iff BTF debug info is enabled. */
142 return (write_symbols
& BTF_DEBUG
);
145 /* Return TRUE iff BTF with CO-RE debug info is enabled. */
148 btf_with_core_debuginfo_p ()
150 return (write_symbols
& BTF_WITH_CORE_DEBUG
);
153 /* Return TRUE iff CTF debug info is enabled. */
158 return (write_symbols
& CTF_DEBUG
);
161 /* Return TRUE iff dwarf2 debug info is enabled. */
164 dwarf_debuginfo_p (struct gcc_options
*opts
)
166 return (opts
->x_write_symbols
& DWARF2_DEBUG
);
169 /* Return true iff the debug info format is to be generated based on DWARF
170 DIEs (like CTF and BTF debug info formats). */
172 bool dwarf_based_debuginfo_p ()
174 return ((write_symbols
& CTF_DEBUG
)
175 || (write_symbols
& BTF_DEBUG
));
178 /* All flag uses below need to explicitely reference the option sets
180 #define global_options DO_NOT_USE
181 #define global_options_set DO_NOT_USE
183 /* Parse the -femit-struct-debug-detailed option value
184 and set the flag variables. */
186 #define MATCH( prefix, string ) \
187 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
188 ? ((string += sizeof prefix - 1), 1) : 0)
191 set_struct_debug_option (struct gcc_options
*opts
, location_t loc
,
194 /* various labels for comparison */
195 static const char dfn_lbl
[] = "dfn:", dir_lbl
[] = "dir:", ind_lbl
[] = "ind:";
196 static const char ord_lbl
[] = "ord:", gen_lbl
[] = "gen:";
197 static const char none_lbl
[] = "none", any_lbl
[] = "any";
198 static const char base_lbl
[] = "base", sys_lbl
[] = "sys";
200 enum debug_struct_file files
= DINFO_STRUCT_FILE_ANY
;
201 /* Default is to apply to as much as possible. */
202 enum debug_info_usage usage
= DINFO_USAGE_NUM_ENUMS
;
203 int ord
= 1, gen
= 1;
206 if (MATCH (dfn_lbl
, spec
))
207 usage
= DINFO_USAGE_DFN
;
208 else if (MATCH (dir_lbl
, spec
))
209 usage
= DINFO_USAGE_DIR_USE
;
210 else if (MATCH (ind_lbl
, spec
))
211 usage
= DINFO_USAGE_IND_USE
;
213 /* Generics or not? */
214 if (MATCH (ord_lbl
, spec
))
216 else if (MATCH (gen_lbl
, spec
))
219 /* What allowable environment? */
220 if (MATCH (none_lbl
, spec
))
221 files
= DINFO_STRUCT_FILE_NONE
;
222 else if (MATCH (any_lbl
, spec
))
223 files
= DINFO_STRUCT_FILE_ANY
;
224 else if (MATCH (sys_lbl
, spec
))
225 files
= DINFO_STRUCT_FILE_SYS
;
226 else if (MATCH (base_lbl
, spec
))
227 files
= DINFO_STRUCT_FILE_BASE
;
230 "argument %qs to %<-femit-struct-debug-detailed%> "
234 /* Effect the specification. */
235 if (usage
== DINFO_USAGE_NUM_ENUMS
)
239 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DFN
] = files
;
240 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
] = files
;
241 opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
] = files
;
245 opts
->x_debug_struct_generic
[DINFO_USAGE_DFN
] = files
;
246 opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
] = files
;
247 opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
] = files
;
253 opts
->x_debug_struct_ordinary
[usage
] = files
;
255 opts
->x_debug_struct_generic
[usage
] = files
;
259 set_struct_debug_option (opts
, loc
, spec
+1);
262 /* No more -femit-struct-debug-detailed specifications.
266 "argument %qs to %<-femit-struct-debug-detailed%> unknown",
268 if (opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
]
269 < opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
]
270 || opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
]
271 < opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
])
273 "%<-femit-struct-debug-detailed=dir:...%> must allow "
274 "at least as much as "
275 "%<-femit-struct-debug-detailed=ind:...%>");
279 /* Strip off a legitimate source ending from the input string NAME of
280 length LEN. Rather than having to know the names used by all of
281 our front ends, we strip off an ending of a period followed by
282 up to fource characters. (C++ uses ".cpp".) */
285 strip_off_ending (char *name
, int len
)
288 for (i
= 2; i
< 5 && len
> i
; i
++)
290 if (name
[len
- i
] == '.')
292 name
[len
- i
] = '\0';
298 /* Find the base name of a path, stripping off both directories and
299 a single final extension. */
301 base_of_path (const char *path
, const char **base_out
)
303 const char *base
= path
;
305 const char *p
= path
;
309 if (IS_DIR_SEPARATOR (c
))
324 /* What to print when a switch has no documentation. */
325 static const char undocumented_msg
[] = N_("This option lacks documentation.");
326 static const char use_diagnosed_msg
[] = N_("Uses of this option are diagnosed.");
328 typedef char *char_p
; /* For DEF_VEC_P. */
330 static void set_debug_level (uint32_t dinfo
, int extended
,
331 const char *arg
, struct gcc_options
*opts
,
332 struct gcc_options
*opts_set
,
334 static void set_fast_math_flags (struct gcc_options
*opts
, int set
);
335 static void decode_d_option (const char *arg
, struct gcc_options
*opts
,
336 location_t loc
, diagnostic_context
*dc
);
337 static void set_unsafe_math_optimizations_flags (struct gcc_options
*opts
,
339 static void enable_warning_as_error (const char *arg
, int value
,
340 unsigned int lang_mask
,
341 const struct cl_option_handlers
*handlers
,
342 struct gcc_options
*opts
,
343 struct gcc_options
*opts_set
,
345 diagnostic_context
*dc
);
347 /* Handle a back-end option; arguments and return value as for
351 target_handle_option (struct gcc_options
*opts
,
352 struct gcc_options
*opts_set
,
353 const struct cl_decoded_option
*decoded
,
354 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
356 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
357 diagnostic_context
*dc
, void (*) (void))
359 gcc_assert (dc
== global_dc
);
360 gcc_assert (kind
== DK_UNSPECIFIED
);
361 return targetm_common
.handle_option (opts
, opts_set
, decoded
, loc
);
364 /* Add comma-separated strings to a char_p vector. */
367 add_comma_separated_to_vector (void **pvec
, const char *arg
)
373 vec
<char_p
> *v
= (vec
<char_p
> *) *pvec
;
375 vec_check_alloc (v
, 1);
377 /* We never free this string. */
390 v
->safe_push (token_start
);
393 if (*r
== '\\' && r
[1] == ',')
403 if (*token_start
!= '\0')
404 v
->safe_push (token_start
);
409 /* Initialize opts_obstack. */
412 init_opts_obstack (void)
414 gcc_obstack_init (&opts_obstack
);
417 /* Initialize OPTS and OPTS_SET before using them in parsing options. */
420 init_options_struct (struct gcc_options
*opts
, struct gcc_options
*opts_set
)
422 /* Ensure that opts_obstack has already been initialized by the time
423 that we initialize any gcc_options instances (PR jit/68446). */
424 gcc_assert (opts_obstack
.chunk_size
> 0);
426 *opts
= global_options_init
;
429 memset (opts_set
, 0, sizeof (*opts_set
));
431 /* Initialize whether `char' is signed. */
432 opts
->x_flag_signed_char
= DEFAULT_SIGNED_CHAR
;
433 /* Set this to a special "uninitialized" value. The actual default
434 is set after target options have been processed. */
435 opts
->x_flag_short_enums
= 2;
437 /* Initialize target_flags before default_options_optimization
438 so the latter can modify it. */
439 opts
->x_target_flags
= targetm_common
.default_target_flags
;
441 /* Some targets have ABI-specified unwind tables. */
442 opts
->x_flag_unwind_tables
= targetm_common
.unwind_tables_default
;
444 /* Some targets have other target-specific initialization. */
445 targetm_common
.option_init_struct (opts
);
448 /* If indicated by the optimization level LEVEL (-Os if SIZE is set,
449 -Ofast if FAST is set, -Og if DEBUG is set), apply the option DEFAULT_OPT
450 to OPTS and OPTS_SET, diagnostic context DC, location LOC, with language
451 mask LANG_MASK and option handlers HANDLERS. */
454 maybe_default_option (struct gcc_options
*opts
,
455 struct gcc_options
*opts_set
,
456 const struct default_options
*default_opt
,
457 int level
, bool size
, bool fast
, bool debug
,
458 unsigned int lang_mask
,
459 const struct cl_option_handlers
*handlers
,
461 diagnostic_context
*dc
)
463 const struct cl_option
*option
= &cl_options
[default_opt
->opt_index
];
467 gcc_assert (level
== 2);
469 gcc_assert (level
== 3);
471 gcc_assert (level
== 1);
473 switch (default_opt
->levels
)
479 case OPT_LEVELS_0_ONLY
:
480 enabled
= (level
== 0);
483 case OPT_LEVELS_1_PLUS
:
484 enabled
= (level
>= 1);
487 case OPT_LEVELS_1_PLUS_SPEED_ONLY
:
488 enabled
= (level
>= 1 && !size
&& !debug
);
491 case OPT_LEVELS_1_PLUS_NOT_DEBUG
:
492 enabled
= (level
>= 1 && !debug
);
495 case OPT_LEVELS_2_PLUS
:
496 enabled
= (level
>= 2);
499 case OPT_LEVELS_2_PLUS_SPEED_ONLY
:
500 enabled
= (level
>= 2 && !size
&& !debug
);
503 case OPT_LEVELS_3_PLUS
:
504 enabled
= (level
>= 3);
507 case OPT_LEVELS_3_PLUS_AND_SIZE
:
508 enabled
= (level
>= 3 || size
);
511 case OPT_LEVELS_SIZE
:
515 case OPT_LEVELS_FAST
:
519 case OPT_LEVELS_NONE
:
525 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
526 default_opt
->arg
, default_opt
->value
,
527 lang_mask
, DK_UNSPECIFIED
, loc
,
529 else if (default_opt
->arg
== NULL
530 && !option
->cl_reject_negative
531 && !(option
->flags
& CL_PARAMS
))
532 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
533 default_opt
->arg
, !default_opt
->value
,
534 lang_mask
, DK_UNSPECIFIED
, loc
,
538 /* As indicated by the optimization level LEVEL (-Os if SIZE is set,
539 -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
540 OPTS and OPTS_SET, diagnostic context DC, location LOC, with
541 language mask LANG_MASK and option handlers HANDLERS. */
544 maybe_default_options (struct gcc_options
*opts
,
545 struct gcc_options
*opts_set
,
546 const struct default_options
*default_opts
,
547 int level
, bool size
, bool fast
, bool debug
,
548 unsigned int lang_mask
,
549 const struct cl_option_handlers
*handlers
,
551 diagnostic_context
*dc
)
555 for (i
= 0; default_opts
[i
].levels
!= OPT_LEVELS_NONE
; i
++)
556 maybe_default_option (opts
, opts_set
, &default_opts
[i
],
557 level
, size
, fast
, debug
,
558 lang_mask
, handlers
, loc
, dc
);
561 /* Table of options enabled by default at different levels.
562 Please keep this list sorted by level and alphabetized within
563 each level; this makes it easier to keep the documentation
566 static const struct default_options default_options_table
[] =
568 /* -O1 and -Og optimizations. */
569 { OPT_LEVELS_1_PLUS
, OPT_fcombine_stack_adjustments
, NULL
, 1 },
570 { OPT_LEVELS_1_PLUS
, OPT_fcompare_elim
, NULL
, 1 },
571 { OPT_LEVELS_1_PLUS
, OPT_fcprop_registers
, NULL
, 1 },
572 { OPT_LEVELS_1_PLUS
, OPT_fdefer_pop
, NULL
, 1 },
573 { OPT_LEVELS_1_PLUS
, OPT_fforward_propagate
, NULL
, 1 },
574 { OPT_LEVELS_1_PLUS
, OPT_fguess_branch_probability
, NULL
, 1 },
575 { OPT_LEVELS_1_PLUS
, OPT_fipa_profile
, NULL
, 1 },
576 { OPT_LEVELS_1_PLUS
, OPT_fipa_pure_const
, NULL
, 1 },
577 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference
, NULL
, 1 },
578 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference_addressable
, NULL
, 1 },
579 { OPT_LEVELS_1_PLUS
, OPT_fmerge_constants
, NULL
, 1 },
580 { OPT_LEVELS_1_PLUS
, OPT_fomit_frame_pointer
, NULL
, 1 },
581 { OPT_LEVELS_1_PLUS
, OPT_freorder_blocks
, NULL
, 1 },
582 { OPT_LEVELS_1_PLUS
, OPT_fshrink_wrap
, NULL
, 1 },
583 { OPT_LEVELS_1_PLUS
, OPT_fsplit_wide_types
, NULL
, 1 },
584 { OPT_LEVELS_1_PLUS
, OPT_fthread_jumps
, NULL
, 1 },
585 { OPT_LEVELS_1_PLUS
, OPT_ftree_builtin_call_dce
, NULL
, 1 },
586 { OPT_LEVELS_1_PLUS
, OPT_ftree_ccp
, NULL
, 1 },
587 { OPT_LEVELS_1_PLUS
, OPT_ftree_ch
, NULL
, 1 },
588 { OPT_LEVELS_1_PLUS
, OPT_ftree_coalesce_vars
, NULL
, 1 },
589 { OPT_LEVELS_1_PLUS
, OPT_ftree_copy_prop
, NULL
, 1 },
590 { OPT_LEVELS_1_PLUS
, OPT_ftree_dce
, NULL
, 1 },
591 { OPT_LEVELS_1_PLUS
, OPT_ftree_dominator_opts
, NULL
, 1 },
592 { OPT_LEVELS_1_PLUS
, OPT_ftree_fre
, NULL
, 1 },
593 { OPT_LEVELS_1_PLUS
, OPT_ftree_sink
, NULL
, 1 },
594 { OPT_LEVELS_1_PLUS
, OPT_ftree_slsr
, NULL
, 1 },
595 { OPT_LEVELS_1_PLUS
, OPT_ftree_ter
, NULL
, 1 },
596 { OPT_LEVELS_1_PLUS
, OPT_fvar_tracking
, NULL
, 1 },
598 /* -O1 (and not -Og) optimizations. */
599 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fbranch_count_reg
, NULL
, 1 },
601 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fdelayed_branch
, NULL
, 1 },
603 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fdse
, NULL
, 1 },
604 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion
, NULL
, 1 },
605 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion2
, NULL
, 1 },
606 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_finline_functions_called_once
, NULL
, 1 },
607 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_invariants
, NULL
, 1 },
608 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_stores
, NULL
, 1 },
609 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fssa_phiopt
, NULL
, 1 },
610 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fipa_modref
, NULL
, 1 },
611 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_bit_ccp
, NULL
, 1 },
612 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_dse
, NULL
, 1 },
613 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_pta
, NULL
, 1 },
614 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_sra
, NULL
, 1 },
616 /* -O2 and -Os optimizations. */
617 { OPT_LEVELS_2_PLUS
, OPT_fcaller_saves
, NULL
, 1 },
618 { OPT_LEVELS_2_PLUS
, OPT_fcode_hoisting
, NULL
, 1 },
619 { OPT_LEVELS_2_PLUS
, OPT_fcrossjumping
, NULL
, 1 },
620 { OPT_LEVELS_2_PLUS
, OPT_fcse_follow_jumps
, NULL
, 1 },
621 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize
, NULL
, 1 },
622 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize_speculatively
, NULL
, 1 },
623 { OPT_LEVELS_2_PLUS
, OPT_fexpensive_optimizations
, NULL
, 1 },
624 { OPT_LEVELS_2_PLUS
, OPT_fgcse
, NULL
, 1 },
625 { OPT_LEVELS_2_PLUS
, OPT_fhoist_adjacent_loads
, NULL
, 1 },
626 { OPT_LEVELS_2_PLUS
, OPT_findirect_inlining
, NULL
, 1 },
627 { OPT_LEVELS_2_PLUS
, OPT_finline_small_functions
, NULL
, 1 },
628 { OPT_LEVELS_2_PLUS
, OPT_fipa_bit_cp
, NULL
, 1 },
629 { OPT_LEVELS_2_PLUS
, OPT_fipa_cp
, NULL
, 1 },
630 { OPT_LEVELS_2_PLUS
, OPT_fipa_icf
, NULL
, 1 },
631 { OPT_LEVELS_2_PLUS
, OPT_fipa_ra
, NULL
, 1 },
632 { OPT_LEVELS_2_PLUS
, OPT_fipa_sra
, NULL
, 1 },
633 { OPT_LEVELS_2_PLUS
, OPT_fipa_vrp
, NULL
, 1 },
634 { OPT_LEVELS_2_PLUS
, OPT_fisolate_erroneous_paths_dereference
, NULL
, 1 },
635 { OPT_LEVELS_2_PLUS
, OPT_flra_remat
, NULL
, 1 },
636 { OPT_LEVELS_2_PLUS
, OPT_foptimize_sibling_calls
, NULL
, 1 },
637 { OPT_LEVELS_2_PLUS
, OPT_fpartial_inlining
, NULL
, 1 },
638 { OPT_LEVELS_2_PLUS
, OPT_fpeephole2
, NULL
, 1 },
639 { OPT_LEVELS_2_PLUS
, OPT_freorder_functions
, NULL
, 1 },
640 { OPT_LEVELS_2_PLUS
, OPT_frerun_cse_after_loop
, NULL
, 1 },
641 #ifdef INSN_SCHEDULING
642 { OPT_LEVELS_2_PLUS
, OPT_fschedule_insns2
, NULL
, 1 },
644 { OPT_LEVELS_2_PLUS
, OPT_fstrict_aliasing
, NULL
, 1 },
645 { OPT_LEVELS_2_PLUS
, OPT_fstore_merging
, NULL
, 1 },
646 { OPT_LEVELS_2_PLUS
, OPT_ftree_pre
, NULL
, 1 },
647 { OPT_LEVELS_2_PLUS
, OPT_ftree_switch_conversion
, NULL
, 1 },
648 { OPT_LEVELS_2_PLUS
, OPT_ftree_tail_merge
, NULL
, 1 },
649 { OPT_LEVELS_2_PLUS
, OPT_ftree_vrp
, NULL
, 1 },
650 { OPT_LEVELS_2_PLUS
, OPT_fvect_cost_model_
, NULL
,
651 VECT_COST_MODEL_VERY_CHEAP
},
652 { OPT_LEVELS_2_PLUS
, OPT_finline_functions
, NULL
, 1 },
653 { OPT_LEVELS_2_PLUS
, OPT_ftree_loop_distribute_patterns
, NULL
, 1 },
655 /* -O2 and above optimizations, but not -Os or -Og. */
656 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_functions
, NULL
, 1 },
657 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_jumps
, NULL
, 1 },
658 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_labels
, NULL
, 1 },
659 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_loops
, NULL
, 1 },
660 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_foptimize_strlen
, NULL
, 1 },
661 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_freorder_blocks_algorithm_
, NULL
,
662 REORDER_BLOCKS_ALGORITHM_STC
},
663 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_ftree_loop_vectorize
, NULL
, 1 },
664 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_ftree_slp_vectorize
, NULL
, 1 },
665 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_fopenmp_target_simd_clone_
, NULL
,
666 OMP_TARGET_SIMD_CLONE_NOHOST
},
667 #ifdef INSN_SCHEDULING
668 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
669 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_fschedule_insns
, NULL
, 1 },
672 /* -O3 and -Os optimizations. */
674 /* -O3 optimizations. */
675 { OPT_LEVELS_3_PLUS
, OPT_fgcse_after_reload
, NULL
, 1 },
676 { OPT_LEVELS_3_PLUS
, OPT_fipa_cp_clone
, NULL
, 1 },
677 { OPT_LEVELS_3_PLUS
, OPT_floop_interchange
, NULL
, 1 },
678 { OPT_LEVELS_3_PLUS
, OPT_floop_unroll_and_jam
, NULL
, 1 },
679 { OPT_LEVELS_3_PLUS
, OPT_fpeel_loops
, NULL
, 1 },
680 { OPT_LEVELS_3_PLUS
, OPT_fpredictive_commoning
, NULL
, 1 },
681 { OPT_LEVELS_3_PLUS
, OPT_fsplit_loops
, NULL
, 1 },
682 { OPT_LEVELS_3_PLUS
, OPT_fsplit_paths
, NULL
, 1 },
683 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribution
, NULL
, 1 },
684 { OPT_LEVELS_3_PLUS
, OPT_ftree_partial_pre
, NULL
, 1 },
685 { OPT_LEVELS_3_PLUS
, OPT_funswitch_loops
, NULL
, 1 },
686 { OPT_LEVELS_3_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_DYNAMIC
},
687 { OPT_LEVELS_3_PLUS
, OPT_fversion_loops_for_strides
, NULL
, 1 },
689 /* -O3 parameters. */
690 { OPT_LEVELS_3_PLUS
, OPT__param_max_inline_insns_auto_
, NULL
, 30 },
691 { OPT_LEVELS_3_PLUS
, OPT__param_early_inlining_insns_
, NULL
, 14 },
692 { OPT_LEVELS_3_PLUS
, OPT__param_inline_heuristics_hint_percent_
, NULL
, 600 },
693 { OPT_LEVELS_3_PLUS
, OPT__param_inline_min_speedup_
, NULL
, 15 },
694 { OPT_LEVELS_3_PLUS
, OPT__param_max_inline_insns_single_
, NULL
, 200 },
696 /* -Ofast adds optimizations to -O3. */
697 { OPT_LEVELS_FAST
, OPT_ffast_math
, NULL
, 1 },
698 { OPT_LEVELS_FAST
, OPT_fallow_store_data_races
, NULL
, 1 },
699 { OPT_LEVELS_FAST
, OPT_fsemantic_interposition
, NULL
, 0 },
701 { OPT_LEVELS_NONE
, 0, NULL
, 0 }
704 /* Default the options in OPTS and OPTS_SET based on the optimization
705 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
707 default_options_optimization (struct gcc_options
*opts
,
708 struct gcc_options
*opts_set
,
709 struct cl_decoded_option
*decoded_options
,
710 unsigned int decoded_options_count
,
712 unsigned int lang_mask
,
713 const struct cl_option_handlers
*handlers
,
714 diagnostic_context
*dc
)
718 bool openacc_mode
= false;
720 /* Scan to see what optimization level has been specified. That will
721 determine the default value of many flags. */
722 for (i
= 1; i
< decoded_options_count
; i
++)
724 struct cl_decoded_option
*opt
= &decoded_options
[i
];
725 switch (opt
->opt_index
)
728 if (*opt
->arg
== '\0')
730 opts
->x_optimize
= 1;
731 opts
->x_optimize_size
= 0;
732 opts
->x_optimize_fast
= 0;
733 opts
->x_optimize_debug
= 0;
737 const int optimize_val
= integral_argument (opt
->arg
);
738 if (optimize_val
== -1)
739 error_at (loc
, "argument to %<-O%> should be a non-negative "
740 "integer, %<g%>, %<s%>, %<z%> or %<fast%>");
743 opts
->x_optimize
= optimize_val
;
744 if ((unsigned int) opts
->x_optimize
> 255)
745 opts
->x_optimize
= 255;
746 opts
->x_optimize_size
= 0;
747 opts
->x_optimize_fast
= 0;
748 opts
->x_optimize_debug
= 0;
754 opts
->x_optimize_size
= 1;
756 /* Optimizing for size forces optimize to be 2. */
757 opts
->x_optimize
= 2;
758 opts
->x_optimize_fast
= 0;
759 opts
->x_optimize_debug
= 0;
763 opts
->x_optimize_size
= 2;
765 /* Optimizing for size forces optimize to be 2. */
766 opts
->x_optimize
= 2;
767 opts
->x_optimize_fast
= 0;
768 opts
->x_optimize_debug
= 0;
772 /* -Ofast only adds flags to -O3. */
773 opts
->x_optimize_size
= 0;
774 opts
->x_optimize
= 3;
775 opts
->x_optimize_fast
= 1;
776 opts
->x_optimize_debug
= 0;
780 /* -Og selects optimization level 1. */
781 opts
->x_optimize_size
= 0;
782 opts
->x_optimize
= 1;
783 opts
->x_optimize_fast
= 0;
784 opts
->x_optimize_debug
= 1;
793 /* Ignore other options in this prescan. */
798 maybe_default_options (opts
, opts_set
, default_options_table
,
799 opts
->x_optimize
, opts
->x_optimize_size
,
800 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
801 lang_mask
, handlers
, loc
, dc
);
803 /* -O2 param settings. */
804 opt2
= (opts
->x_optimize
>= 2);
807 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_pta
, true);
809 /* Track fields in field-sensitive alias analysis. */
811 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_fields_for_field_sensitive
,
814 if (opts
->x_optimize_size
)
815 /* We want to crossjump as much as possible. */
816 SET_OPTION_IF_UNSET (opts
, opts_set
, param_min_crossjump_insns
, 1);
818 /* Restrict the amount of work combine does at -Og while retaining
819 most of its useful transforms. */
820 if (opts
->x_optimize_debug
)
821 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_combine_insns
, 2);
823 /* Allow default optimizations to be specified on a per-machine basis. */
824 maybe_default_options (opts
, opts_set
,
825 targetm_common
.option_optimization_table
,
826 opts
->x_optimize
, opts
->x_optimize_size
,
827 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
828 lang_mask
, handlers
, loc
, dc
);
831 /* Control IPA optimizations based on different live patching LEVEL. */
833 control_options_for_live_patching (struct gcc_options
*opts
,
834 struct gcc_options
*opts_set
,
835 enum live_patching_level level
,
838 gcc_assert (level
> LIVE_PATCHING_NONE
);
842 case LIVE_PATCHING_INLINE_ONLY_STATIC
:
843 #define LIVE_PATCHING_OPTION "-flive-patching=inline-only-static"
844 if (opts_set
->x_flag_ipa_cp_clone
&& opts
->x_flag_ipa_cp_clone
)
845 error_at (loc
, "%qs is incompatible with %qs",
846 "-fipa-cp-clone", LIVE_PATCHING_OPTION
);
848 opts
->x_flag_ipa_cp_clone
= 0;
850 if (opts_set
->x_flag_ipa_sra
&& opts
->x_flag_ipa_sra
)
851 error_at (loc
, "%qs is incompatible with %qs",
852 "-fipa-sra", LIVE_PATCHING_OPTION
);
854 opts
->x_flag_ipa_sra
= 0;
856 if (opts_set
->x_flag_partial_inlining
&& opts
->x_flag_partial_inlining
)
857 error_at (loc
, "%qs is incompatible with %qs",
858 "-fpartial-inlining", LIVE_PATCHING_OPTION
);
860 opts
->x_flag_partial_inlining
= 0;
862 if (opts_set
->x_flag_ipa_cp
&& opts
->x_flag_ipa_cp
)
863 error_at (loc
, "%qs is incompatible with %qs",
864 "-fipa-cp", LIVE_PATCHING_OPTION
);
866 opts
->x_flag_ipa_cp
= 0;
869 case LIVE_PATCHING_INLINE_CLONE
:
870 #undef LIVE_PATCHING_OPTION
871 #define LIVE_PATCHING_OPTION "-flive-patching=inline-only-static|inline-clone"
872 /* live patching should disable whole-program optimization. */
873 if (opts_set
->x_flag_whole_program
&& opts
->x_flag_whole_program
)
874 error_at (loc
, "%qs is incompatible with %qs",
875 "-fwhole-program", LIVE_PATCHING_OPTION
);
877 opts
->x_flag_whole_program
= 0;
879 /* visibility change should be excluded by !flag_whole_program
880 && !in_lto_p && !flag_ipa_cp_clone && !flag_ipa_sra
881 && !flag_partial_inlining. */
883 if (opts_set
->x_flag_ipa_pta
&& opts
->x_flag_ipa_pta
)
884 error_at (loc
, "%qs is incompatible with %qs",
885 "-fipa-pta", LIVE_PATCHING_OPTION
);
887 opts
->x_flag_ipa_pta
= 0;
889 if (opts_set
->x_flag_ipa_reference
&& opts
->x_flag_ipa_reference
)
890 error_at (loc
, "%qs is incompatible with %qs",
891 "-fipa-reference", LIVE_PATCHING_OPTION
);
893 opts
->x_flag_ipa_reference
= 0;
895 if (opts_set
->x_flag_ipa_ra
&& opts
->x_flag_ipa_ra
)
896 error_at (loc
, "%qs is incompatible with %qs",
897 "-fipa-ra", LIVE_PATCHING_OPTION
);
899 opts
->x_flag_ipa_ra
= 0;
901 if (opts_set
->x_flag_ipa_icf
&& opts
->x_flag_ipa_icf
)
902 error_at (loc
, "%qs is incompatible with %qs",
903 "-fipa-icf", LIVE_PATCHING_OPTION
);
905 opts
->x_flag_ipa_icf
= 0;
907 if (opts_set
->x_flag_ipa_icf_functions
&& opts
->x_flag_ipa_icf_functions
)
908 error_at (loc
, "%qs is incompatible with %qs",
909 "-fipa-icf-functions", LIVE_PATCHING_OPTION
);
911 opts
->x_flag_ipa_icf_functions
= 0;
913 if (opts_set
->x_flag_ipa_icf_variables
&& opts
->x_flag_ipa_icf_variables
)
914 error_at (loc
, "%qs is incompatible with %qs",
915 "-fipa-icf-variables", LIVE_PATCHING_OPTION
);
917 opts
->x_flag_ipa_icf_variables
= 0;
919 if (opts_set
->x_flag_ipa_bit_cp
&& opts
->x_flag_ipa_bit_cp
)
920 error_at (loc
, "%qs is incompatible with %qs",
921 "-fipa-bit-cp", LIVE_PATCHING_OPTION
);
923 opts
->x_flag_ipa_bit_cp
= 0;
925 if (opts_set
->x_flag_ipa_vrp
&& opts
->x_flag_ipa_vrp
)
926 error_at (loc
, "%qs is incompatible with %qs",
927 "-fipa-vrp", LIVE_PATCHING_OPTION
);
929 opts
->x_flag_ipa_vrp
= 0;
931 if (opts_set
->x_flag_ipa_pure_const
&& opts
->x_flag_ipa_pure_const
)
932 error_at (loc
, "%qs is incompatible with %qs",
933 "-fipa-pure-const", LIVE_PATCHING_OPTION
);
935 opts
->x_flag_ipa_pure_const
= 0;
937 if (opts_set
->x_flag_ipa_modref
&& opts
->x_flag_ipa_modref
)
939 "%<-fipa-modref%> is incompatible with %qs",
940 LIVE_PATCHING_OPTION
);
942 opts
->x_flag_ipa_modref
= 0;
944 /* FIXME: disable unreachable code removal. */
946 /* discovery of functions/variables with no address taken. */
947 if (opts_set
->x_flag_ipa_reference_addressable
948 && opts
->x_flag_ipa_reference_addressable
)
949 error_at (loc
, "%qs is incompatible with %qs",
950 "-fipa-reference-addressable", LIVE_PATCHING_OPTION
);
952 opts
->x_flag_ipa_reference_addressable
= 0;
954 /* ipa stack alignment propagation. */
955 if (opts_set
->x_flag_ipa_stack_alignment
956 && opts
->x_flag_ipa_stack_alignment
)
957 error_at (loc
, "%qs is incompatible with %qs",
958 "-fipa-stack-alignment", LIVE_PATCHING_OPTION
);
960 opts
->x_flag_ipa_stack_alignment
= 0;
966 #undef LIVE_PATCHING_OPTION
969 /* --help option argument if set. */
970 vec
<const char *> help_option_arguments
;
972 /* Return the string name describing a sanitizer argument which has been
973 provided on the command line and has set this particular flag. */
975 find_sanitizer_argument (struct gcc_options
*opts
, unsigned int flags
)
977 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
979 /* Need to find the sanitizer_opts element which:
980 a) Could have set the flags requested.
981 b) Has been set on the command line.
983 Can have (a) without (b) if the flag requested is e.g.
984 SANITIZE_ADDRESS, since both -fsanitize=address and
985 -fsanitize=kernel-address set this flag.
987 Can have (b) without (a) by requesting more than one sanitizer on the
989 if ((sanitizer_opts
[i
].flag
& opts
->x_flag_sanitize
)
990 != sanitizer_opts
[i
].flag
)
992 if ((sanitizer_opts
[i
].flag
& flags
) != flags
)
994 return sanitizer_opts
[i
].name
;
1000 /* Report an error to the user about sanitizer options they have requested
1001 which have set conflicting flags.
1003 LEFT and RIGHT indicate sanitizer flags which conflict with each other, this
1004 function reports an error if both have been set in OPTS->x_flag_sanitize and
1005 ensures the error identifies the requested command line options that have
1008 report_conflicting_sanitizer_options (struct gcc_options
*opts
, location_t loc
,
1009 unsigned int left
, unsigned int right
)
1011 unsigned int left_seen
= (opts
->x_flag_sanitize
& left
);
1012 unsigned int right_seen
= (opts
->x_flag_sanitize
& right
);
1013 if (left_seen
&& right_seen
)
1015 const char* left_arg
= find_sanitizer_argument (opts
, left_seen
);
1016 const char* right_arg
= find_sanitizer_argument (opts
, right_seen
);
1017 gcc_assert (left_arg
&& right_arg
);
1019 "%<-fsanitize=%s%> is incompatible with %<-fsanitize=%s%>",
1020 left_arg
, right_arg
);
1024 /* After all options at LOC have been read into OPTS and OPTS_SET,
1025 finalize settings of those options and diagnose incompatible
1028 finish_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
1031 if (opts
->x_dump_base_name
1032 && ! opts
->x_dump_base_name_prefixed
)
1034 const char *sep
= opts
->x_dump_base_name
;
1037 if (IS_DIR_SEPARATOR (*sep
))
1041 /* If dump_base_path contains subdirectories, don't prepend
1043 else if (opts
->x_dump_dir_name
)
1044 /* We have a DUMP_DIR_NAME, prepend that. */
1045 opts
->x_dump_base_name
= opts_concat (opts
->x_dump_dir_name
,
1046 opts
->x_dump_base_name
, NULL
);
1048 /* It is definitely prefixed now. */
1049 opts
->x_dump_base_name_prefixed
= true;
1052 /* Handle related options for unit-at-a-time, toplevel-reorder, and
1054 if (!opts
->x_flag_unit_at_a_time
)
1056 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
1057 error_at (loc
, "section anchors must be disabled when unit-at-a-time "
1059 opts
->x_flag_section_anchors
= 0;
1060 if (opts
->x_flag_toplevel_reorder
== 1)
1061 error_at (loc
, "toplevel reorder must be disabled when unit-at-a-time "
1063 opts
->x_flag_toplevel_reorder
= 0;
1066 /* -fself-test depends on the state of the compiler prior to
1067 compiling anything. Ideally it should be run on an empty source
1068 file. However, in case we get run with actual source, assume
1069 -fsyntax-only which will inhibit any compiler initialization
1070 which may confuse the self tests. */
1071 if (opts
->x_flag_self_test
)
1072 opts
->x_flag_syntax_only
= 1;
1074 if (opts
->x_flag_tm
&& opts
->x_flag_non_call_exceptions
)
1075 sorry ("transactional memory is not supported with non-call exceptions");
1077 /* Unless the user has asked for section anchors, we disable toplevel
1078 reordering at -O0 to disable transformations that might be surprising
1079 to end users and to get -fno-toplevel-reorder tested. */
1080 if (!opts
->x_optimize
1081 && opts
->x_flag_toplevel_reorder
== 2
1082 && !(opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
))
1084 opts
->x_flag_toplevel_reorder
= 0;
1085 opts
->x_flag_section_anchors
= 0;
1087 if (!opts
->x_flag_toplevel_reorder
)
1089 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
1090 error_at (loc
, "section anchors must be disabled when toplevel reorder"
1092 opts
->x_flag_section_anchors
= 0;
1095 if (!opts
->x_flag_opts_finished
)
1097 /* We initialize opts->x_flag_pie to -1 so that targets can set a
1099 if (opts
->x_flag_pie
== -1)
1101 /* We initialize opts->x_flag_pic to -1 so that we can tell if
1102 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
1103 if (opts
->x_flag_pic
== -1)
1104 opts
->x_flag_pie
= DEFAULT_FLAG_PIE
;
1106 opts
->x_flag_pie
= 0;
1108 /* If -fPIE or -fpie is used, turn on PIC. */
1109 if (opts
->x_flag_pie
)
1110 opts
->x_flag_pic
= opts
->x_flag_pie
;
1111 else if (opts
->x_flag_pic
== -1)
1112 opts
->x_flag_pic
= 0;
1113 if (opts
->x_flag_pic
&& !opts
->x_flag_pie
)
1114 opts
->x_flag_shlib
= 1;
1115 opts
->x_flag_opts_finished
= true;
1118 /* We initialize opts->x_flag_stack_protect to -1 so that targets
1119 can set a default value. */
1120 if (opts
->x_flag_stack_protect
== -1)
1121 opts
->x_flag_stack_protect
= DEFAULT_FLAG_SSP
;
1123 if (opts
->x_optimize
== 0)
1125 /* Inlining does not work if not optimizing,
1126 so force it not to be done. */
1127 opts
->x_warn_inline
= 0;
1128 opts
->x_flag_no_inline
= 1;
1131 /* At -O0 or -Og, turn __builtin_unreachable into a trap. */
1132 if (!opts
->x_optimize
|| opts
->x_optimize_debug
)
1133 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unreachable_traps
, true);
1135 /* Pipelining of outer loops is only possible when general pipelining
1136 capabilities are requested. */
1137 if (!opts
->x_flag_sel_sched_pipelining
)
1138 opts
->x_flag_sel_sched_pipelining_outer_loops
= 0;
1140 if (opts
->x_flag_conserve_stack
)
1142 SET_OPTION_IF_UNSET (opts
, opts_set
, param_large_stack_frame
, 100);
1143 SET_OPTION_IF_UNSET (opts
, opts_set
, param_stack_frame_growth
, 40);
1146 if (opts
->x_flag_lto
)
1149 opts
->x_flag_generate_lto
= 1;
1151 /* When generating IL, do not operate in whole-program mode.
1152 Otherwise, symbols will be privatized too early, causing link
1154 opts
->x_flag_whole_program
= 0;
1156 error_at (loc
, "LTO support has not been enabled in this configuration");
1158 if (!opts
->x_flag_fat_lto_objects
1159 && (!HAVE_LTO_PLUGIN
1160 || (opts_set
->x_flag_use_linker_plugin
1161 && !opts
->x_flag_use_linker_plugin
)))
1163 if (opts_set
->x_flag_fat_lto_objects
)
1164 error_at (loc
, "%<-fno-fat-lto-objects%> are supported only with "
1166 opts
->x_flag_fat_lto_objects
= 1;
1169 /* -gsplit-dwarf isn't compatible with LTO, see PR88389. */
1170 if (opts
->x_dwarf_split_debug_info
)
1172 inform (loc
, "%<-gsplit-dwarf%> is not supported with LTO,"
1174 opts
->x_dwarf_split_debug_info
= 0;
1178 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
1179 default value if they choose based on other options. */
1180 if (opts
->x_flag_split_stack
== -1)
1181 opts
->x_flag_split_stack
= 0;
1182 else if (opts
->x_flag_split_stack
)
1184 if (!targetm_common
.supports_split_stack (true, opts
))
1186 error_at (loc
, "%<-fsplit-stack%> is not supported by "
1187 "this compiler configuration");
1188 opts
->x_flag_split_stack
= 0;
1192 /* If stack splitting is turned on, and the user did not explicitly
1193 request function partitioning, turn off partitioning, as it
1194 confuses the linker when trying to handle partitioned split-stack
1195 code that calls a non-split-stack functions. But if partitioning
1196 was turned on explicitly just hope for the best. */
1197 if (opts
->x_flag_split_stack
1198 && opts
->x_flag_reorder_blocks_and_partition
)
1199 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_reorder_blocks_and_partition
, 0);
1201 if (opts
->x_flag_reorder_blocks_and_partition
)
1202 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_reorder_functions
, 1);
1204 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
1205 if (opts
->x_dwarf_split_debug_info
)
1206 opts
->x_debug_generate_pub_sections
= 2;
1208 if ((opts
->x_flag_sanitize
1209 & (SANITIZE_USER_ADDRESS
| SANITIZE_KERNEL_ADDRESS
)) == 0)
1211 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_COMPARE
)
1213 "%<-fsanitize=pointer-compare%> must be combined with "
1214 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1215 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_SUBTRACT
)
1217 "%<-fsanitize=pointer-subtract%> must be combined with "
1218 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1221 /* Address sanitizers conflict with the thread sanitizer. */
1222 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_THREAD
,
1224 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_THREAD
,
1225 SANITIZE_HWADDRESS
);
1226 /* The leak sanitizer conflicts with the thread sanitizer. */
1227 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_LEAK
,
1230 /* No combination of HWASAN and ASAN work together. */
1231 report_conflicting_sanitizer_options (opts
, loc
,
1232 SANITIZE_HWADDRESS
, SANITIZE_ADDRESS
);
1234 /* The userspace and kernel address sanitizers conflict with each other. */
1235 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_USER_HWADDRESS
,
1236 SANITIZE_KERNEL_HWADDRESS
);
1237 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_USER_ADDRESS
,
1238 SANITIZE_KERNEL_ADDRESS
);
1240 /* Check error recovery for -fsanitize-recover option. */
1241 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1242 if ((opts
->x_flag_sanitize_recover
& sanitizer_opts
[i
].flag
)
1243 && !sanitizer_opts
[i
].can_recover
)
1244 error_at (loc
, "%<-fsanitize-recover=%s%> is not supported",
1245 sanitizer_opts
[i
].name
);
1247 /* Check -fsanitize-trap option. */
1248 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1249 if ((opts
->x_flag_sanitize_trap
& sanitizer_opts
[i
].flag
)
1250 && !sanitizer_opts
[i
].can_trap
1251 /* Allow -fsanitize-trap=all or -fsanitize-trap=undefined
1252 to set flag_sanitize_trap & SANITIZE_VPTR bit which will
1253 effectively disable -fsanitize=vptr, just disallow
1254 explicit -fsanitize-trap=vptr. */
1255 && sanitizer_opts
[i
].flag
!= SANITIZE_VPTR
)
1256 error_at (loc
, "%<-fsanitize-trap=%s%> is not supported",
1257 sanitizer_opts
[i
].name
);
1259 /* When instrumenting the pointers, we don't want to remove
1260 the null pointer checks. */
1261 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
1262 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
1263 opts
->x_flag_delete_null_pointer_checks
= 0;
1265 /* Aggressive compiler optimizations may cause false negatives. */
1266 if (opts
->x_flag_sanitize
& ~(SANITIZE_LEAK
| SANITIZE_UNREACHABLE
))
1267 opts
->x_flag_aggressive_loop_optimizations
= 0;
1269 /* Enable -fsanitize-address-use-after-scope if either address sanitizer is
1271 if (opts
->x_flag_sanitize
1272 & (SANITIZE_USER_ADDRESS
| SANITIZE_USER_HWADDRESS
))
1273 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_sanitize_address_use_after_scope
,
1276 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1278 if (opts
->x_flag_sanitize_address_use_after_scope
)
1280 if (opts
->x_flag_stack_reuse
!= SR_NONE
1281 && opts_set
->x_flag_stack_reuse
!= SR_NONE
)
1283 "%<-fsanitize-address-use-after-scope%> requires "
1284 "%<-fstack-reuse=none%> option");
1286 opts
->x_flag_stack_reuse
= SR_NONE
;
1289 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
) && opts
->x_flag_tm
)
1290 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1292 if ((opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) && opts
->x_flag_tm
)
1293 sorry ("transactional memory is not supported with "
1294 "%<-fsanitize=kernel-address%>");
1296 /* Currently live patching is not support for LTO. */
1297 if (opts
->x_flag_live_patching
== LIVE_PATCHING_INLINE_ONLY_STATIC
&& opts
->x_flag_lto
)
1298 sorry ("live patching (with %qs) is not supported with LTO",
1299 "inline-only-static");
1301 /* Currently vtable verification is not supported for LTO */
1302 if (opts
->x_flag_vtable_verify
&& opts
->x_flag_lto
)
1303 sorry ("vtable verification is not supported with LTO");
1305 /* Control IPA optimizations based on different -flive-patching level. */
1306 if (opts
->x_flag_live_patching
)
1307 control_options_for_live_patching (opts
, opts_set
,
1308 opts
->x_flag_live_patching
,
1311 /* Allow cunroll to grow size accordingly. */
1312 if (!opts_set
->x_flag_cunroll_grow_size
)
1313 opts
->x_flag_cunroll_grow_size
1314 = (opts
->x_flag_unroll_loops
1315 || opts
->x_flag_peel_loops
1316 || opts
->x_optimize
>= 3);
1318 /* With -fcx-limited-range, we do cheap and quick complex arithmetic. */
1319 if (opts
->x_flag_cx_limited_range
)
1320 opts
->x_flag_complex_method
= 0;
1321 else if (opts_set
->x_flag_cx_limited_range
)
1322 opts
->x_flag_complex_method
= opts
->x_flag_default_complex_method
;
1324 /* With -fcx-fortran-rules, we do something in-between cheap and C99. */
1325 if (opts
->x_flag_cx_fortran_rules
)
1326 opts
->x_flag_complex_method
= 1;
1327 else if (opts_set
->x_flag_cx_fortran_rules
)
1328 opts
->x_flag_complex_method
= opts
->x_flag_default_complex_method
;
1330 /* Use -fvect-cost-model=cheap instead of -fvect-cost-mode=very-cheap
1331 by default with explicit -ftree-{loop,slp}-vectorize. */
1332 if (opts
->x_optimize
== 2
1333 && (opts_set
->x_flag_tree_loop_vectorize
1334 || opts_set
->x_flag_tree_vectorize
))
1335 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_vect_cost_model
,
1336 VECT_COST_MODEL_CHEAP
);
1338 if (opts
->x_flag_gtoggle
)
1340 /* Make sure to process -gtoggle only once. */
1341 opts
->x_flag_gtoggle
= false;
1342 if (opts
->x_debug_info_level
== DINFO_LEVEL_NONE
)
1344 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
1346 if (opts
->x_write_symbols
== NO_DEBUG
)
1347 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
1350 opts
->x_debug_info_level
= DINFO_LEVEL_NONE
;
1353 if (!opts_set
->x_debug_nonbind_markers_p
)
1354 opts
->x_debug_nonbind_markers_p
1356 && opts
->x_debug_info_level
>= DINFO_LEVEL_NORMAL
1357 && dwarf_debuginfo_p (opts
)
1358 && !(opts
->x_flag_selective_scheduling
1359 || opts
->x_flag_selective_scheduling2
));
1361 /* We know which debug output will be used so we can set flag_var_tracking
1362 and flag_var_tracking_uninit if the user has not specified them. */
1363 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
1364 || !dwarf_debuginfo_p (opts
)
1365 /* We have not yet initialized debug hooks so match that to check
1366 whether we're only doing DWARF2_LINENO_DEBUGGING_INFO. */
1367 #ifndef DWARF2_DEBUGGING_INFO
1372 if ((opts_set
->x_flag_var_tracking
&& opts
->x_flag_var_tracking
== 1)
1373 || (opts_set
->x_flag_var_tracking_uninit
1374 && opts
->x_flag_var_tracking_uninit
== 1))
1376 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
1377 warning_at (UNKNOWN_LOCATION
, 0,
1378 "variable tracking requested, but useless unless "
1379 "producing debug info");
1381 warning_at (UNKNOWN_LOCATION
, 0,
1382 "variable tracking requested, but not supported "
1383 "by this debug format");
1385 opts
->x_flag_var_tracking
= 0;
1386 opts
->x_flag_var_tracking_uninit
= 0;
1389 /* One could use EnabledBy, but it would lead to a circular dependency. */
1390 if (!opts_set
->x_flag_var_tracking_uninit
)
1391 opts
->x_flag_var_tracking_uninit
= opts
->x_flag_var_tracking
;
1393 if (!opts_set
->x_flag_var_tracking_assignments
)
1394 opts
->x_flag_var_tracking_assignments
1395 = (opts
->x_flag_var_tracking
1396 && !(opts
->x_flag_selective_scheduling
1397 || opts
->x_flag_selective_scheduling2
));
1399 if (opts
->x_flag_var_tracking_assignments_toggle
)
1400 opts
->x_flag_var_tracking_assignments
1401 = !opts
->x_flag_var_tracking_assignments
;
1403 if (opts
->x_flag_var_tracking_assignments
&& !opts
->x_flag_var_tracking
)
1404 opts
->x_flag_var_tracking
= opts
->x_flag_var_tracking_assignments
= -1;
1406 if (opts
->x_flag_var_tracking_assignments
1407 && (opts
->x_flag_selective_scheduling
1408 || opts
->x_flag_selective_scheduling2
))
1410 "var-tracking-assignments changes selective scheduling");
1412 if (opts
->x_flag_syntax_only
)
1414 opts
->x_write_symbols
= NO_DEBUG
;
1415 opts
->x_profile_flag
= 0;
1418 if (opts
->x_warn_strict_flex_arrays
)
1419 if (opts
->x_flag_strict_flex_arrays
== 0)
1421 opts
->x_warn_strict_flex_arrays
= 0;
1422 warning_at (UNKNOWN_LOCATION
, 0,
1423 "%<-Wstrict-flex-arrays%> is ignored when"
1424 " %<-fstrict-flex-arrays%> is not present");
1427 diagnose_options (opts
, opts_set
, loc
);
1430 /* The function diagnoses incompatible combinations for provided options
1431 (OPTS and OPTS_SET) at a given LOCation. The function is called both
1432 when command line is parsed (after the target optimization hook) and
1433 when an optimize/target attribute (or pragma) is used. */
1435 void diagnose_options (gcc_options
*opts
, gcc_options
*opts_set
,
1438 /* The optimization to partition hot and cold basic blocks into separate
1439 sections of the .o and executable files does not work (currently)
1440 with exception handling. This is because there is no support for
1441 generating unwind info. If opts->x_flag_exceptions is turned on
1442 we need to turn off the partitioning optimization. */
1444 enum unwind_info_type ui_except
1445 = targetm_common
.except_unwind_info (opts
);
1447 if (opts
->x_flag_exceptions
1448 && opts
->x_flag_reorder_blocks_and_partition
1449 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1451 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1453 "%<-freorder-blocks-and-partition%> does not work "
1454 "with exceptions on this architecture");
1455 opts
->x_flag_reorder_blocks_and_partition
= 0;
1456 opts
->x_flag_reorder_blocks
= 1;
1459 /* If user requested unwind info, then turn off the partitioning
1462 if (opts
->x_flag_unwind_tables
1463 && !targetm_common
.unwind_tables_default
1464 && opts
->x_flag_reorder_blocks_and_partition
1465 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1467 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1469 "%<-freorder-blocks-and-partition%> does not support "
1470 "unwind info on this architecture");
1471 opts
->x_flag_reorder_blocks_and_partition
= 0;
1472 opts
->x_flag_reorder_blocks
= 1;
1475 /* If the target requested unwind info, then turn off the partitioning
1476 optimization with a different message. Likewise, if the target does not
1477 support named sections. */
1479 if (opts
->x_flag_reorder_blocks_and_partition
1480 && (!targetm_common
.have_named_sections
1481 || (opts
->x_flag_unwind_tables
1482 && targetm_common
.unwind_tables_default
1483 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
1485 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1487 "%<-freorder-blocks-and-partition%> does not work "
1488 "on this architecture");
1489 opts
->x_flag_reorder_blocks_and_partition
= 0;
1490 opts
->x_flag_reorder_blocks
= 1;
1496 #define LEFT_COLUMN 27
1498 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1499 followed by word-wrapped HELP in a second column. */
1501 wrap_help (const char *help
,
1503 unsigned int item_width
,
1504 unsigned int columns
)
1506 unsigned int col_width
= LEFT_COLUMN
;
1507 unsigned int remaining
, room
, len
;
1509 remaining
= strlen (help
);
1513 room
= columns
- 3 - MAX (col_width
, item_width
);
1522 for (i
= 0; help
[i
]; i
++)
1524 if (i
>= room
&& len
!= remaining
)
1528 else if ((help
[i
] == '-' || help
[i
] == '/')
1529 && help
[i
+ 1] != ' '
1530 && i
> 0 && ISALPHA (help
[i
- 1]))
1535 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1537 while (help
[len
] == ' ')
1545 /* Data structure used to print list of valid option values. */
1547 class option_help_tuple
1550 option_help_tuple (int code
, vec
<const char *> values
):
1551 m_code (code
), m_values (values
)
1554 /* Code of an option. */
1557 /* List of possible values. */
1558 vec
<const char *> m_values
;
1561 /* Print help for a specific front-end, etc. */
1563 print_filtered_help (unsigned int include_flags
,
1564 unsigned int exclude_flags
,
1565 unsigned int any_flags
,
1566 unsigned int columns
,
1567 struct gcc_options
*opts
,
1568 unsigned int lang_mask
)
1573 bool displayed
= false;
1576 if (!opts
->x_help_printed
)
1577 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1579 if (!opts
->x_help_enum_printed
)
1580 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1582 auto_vec
<option_help_tuple
> help_tuples
;
1584 for (i
= 0; i
< cl_options_count
; i
++)
1586 const struct cl_option
*option
= cl_options
+ i
;
1591 if (include_flags
== 0
1592 || ((option
->flags
& include_flags
) != include_flags
))
1594 if ((option
->flags
& any_flags
) == 0)
1598 /* Skip unwanted switches. */
1599 if ((option
->flags
& exclude_flags
) != 0)
1602 /* The driver currently prints its own help text. */
1603 if ((option
->flags
& CL_DRIVER
) != 0
1604 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1605 | CL_COMMON
| CL_TARGET
)) == 0)
1608 /* If an option contains a language specification,
1609 exclude it from common unless all languages are present. */
1610 if ((include_flags
& CL_COMMON
)
1611 && !(option
->flags
& CL_DRIVER
)
1612 && (option
->flags
& CL_LANG_ALL
)
1613 && (option
->flags
& CL_LANG_ALL
) != CL_LANG_ALL
)
1617 /* Skip switches that have already been printed. */
1618 if (opts
->x_help_printed
[i
])
1621 opts
->x_help_printed
[i
] = true;
1623 help
= option
->help
;
1626 if (exclude_flags
& CL_UNDOCUMENTED
)
1629 help
= undocumented_msg
;
1632 /* Get the translation. */
1635 if (option
->alias_target
< N_OPTS
1636 && cl_options
[option
->alias_target
].help
)
1638 const struct cl_option
*target
= cl_options
+ option
->alias_target
;
1639 if (option
->help
== NULL
)
1641 /* The option is undocumented but is an alias for an option that
1642 is documented. If the option has alias arguments, then its
1643 purpose is to provide certain arguments to the other option, so
1644 inform the reader of this. Otherwise, point the reader to the
1645 other option in preference to the former. */
1647 if (option
->alias_arg
)
1649 if (option
->neg_alias_arg
)
1650 snprintf (new_help
, sizeof new_help
,
1651 _("Same as %s%s (or, in negated form, %s%s)."),
1652 target
->opt_text
, option
->alias_arg
,
1653 target
->opt_text
, option
->neg_alias_arg
);
1655 snprintf (new_help
, sizeof new_help
,
1657 target
->opt_text
, option
->alias_arg
);
1660 snprintf (new_help
, sizeof new_help
,
1666 /* For documented options with aliases, mention the aliased
1667 option's name for reference. */
1668 snprintf (new_help
, sizeof new_help
,
1669 _("%s Same as %s."),
1670 help
, cl_options
[option
->alias_target
].opt_text
);
1676 if (option
->warn_message
)
1678 /* Mention that the use of the option will trigger a warning. */
1679 if (help
== new_help
)
1680 snprintf (new_help
+ strlen (new_help
),
1681 sizeof new_help
- strlen (new_help
),
1682 " %s", _(use_diagnosed_msg
));
1684 snprintf (new_help
, sizeof new_help
,
1685 "%s %s", help
, _(use_diagnosed_msg
));
1690 /* Find the gap between the name of the
1691 option and its descriptive text. */
1692 tab
= strchr (help
, '\t');
1701 opt
= option
->opt_text
;
1705 /* With the -Q option enabled we change the descriptive text associated
1706 with an option to be an indication of its current setting. */
1707 if (!opts
->x_quiet_flag
)
1709 void *flag_var
= option_flag_var (i
, opts
);
1711 if (len
< (LEFT_COLUMN
+ 2))
1712 strcpy (new_help
, "\t\t");
1714 strcpy (new_help
, "\t");
1716 /* Set to print whether the option is enabled or disabled,
1717 or, if it's an alias for another option, the name of
1718 the aliased option. */
1719 bool print_state
= false;
1721 if (flag_var
!= NULL
1722 && option
->var_type
!= CLVC_DEFER
)
1724 /* If OPTION is only available for a specific subset
1725 of languages other than this one, mention them. */
1726 bool avail_for_lang
= true;
1727 if (unsigned langset
= option
->flags
& CL_LANG_ALL
)
1729 if (!(langset
& lang_mask
))
1731 avail_for_lang
= false;
1732 strcat (new_help
, _("[available in "));
1733 for (unsigned i
= 0, n
= 0; (1U << i
) < CL_LANG_ALL
; ++i
)
1734 if (langset
& (1U << i
))
1737 strcat (new_help
, ", ");
1738 strcat (new_help
, lang_names
[i
]);
1740 strcat (new_help
, "]");
1743 if (!avail_for_lang
)
1744 ; /* Print nothing else if the option is not available
1745 in the current language. */
1746 else if (option
->flags
& CL_JOINED
)
1748 if (option
->var_type
== CLVC_STRING
)
1750 if (* (const char **) flag_var
!= NULL
)
1751 snprintf (new_help
+ strlen (new_help
),
1752 sizeof (new_help
) - strlen (new_help
),
1753 "%s", * (const char **) flag_var
);
1755 else if (option
->var_type
== CLVC_ENUM
)
1757 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1759 const char *arg
= NULL
;
1761 value
= e
->get (flag_var
);
1762 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1764 arg
= _("[default]");
1765 snprintf (new_help
+ strlen (new_help
),
1766 sizeof (new_help
) - strlen (new_help
),
1771 if (option
->cl_host_wide_int
)
1772 sprintf (new_help
+ strlen (new_help
),
1773 _("%llu bytes"), (unsigned long long)
1774 *(unsigned HOST_WIDE_INT
*) flag_var
);
1776 sprintf (new_help
+ strlen (new_help
),
1777 "%i", * (int *) flag_var
);
1784 /* When there is no argument, print the option state only
1785 if the option takes no argument. */
1786 print_state
= !(option
->flags
& CL_JOINED
);
1790 if (option
->alias_target
< N_OPTS
1791 && option
->alias_target
!= OPT_SPECIAL_warn_removed
1792 && option
->alias_target
!= OPT_SPECIAL_ignore
1793 && option
->alias_target
!= OPT_SPECIAL_input_file
1794 && option
->alias_target
!= OPT_SPECIAL_program_name
1795 && option
->alias_target
!= OPT_SPECIAL_unknown
)
1797 const struct cl_option
*target
1798 = &cl_options
[option
->alias_target
];
1799 sprintf (new_help
+ strlen (new_help
), "%s%s",
1801 option
->alias_arg
? option
->alias_arg
: "");
1803 else if (option
->alias_target
== OPT_SPECIAL_ignore
)
1804 strcat (new_help
, ("[ignored]"));
1807 /* Print the state for an on/off option. */
1808 int ena
= option_enabled (i
, lang_mask
, opts
);
1810 strcat (new_help
, _("[enabled]"));
1812 strcat (new_help
, _("[disabled]"));
1819 if (option
->range_max
!= -1 && tab
== NULL
)
1822 snprintf (b
, sizeof (b
), "<%d,%d>", option
->range_min
,
1824 opt
= concat (opt
, b
, NULL
);
1828 wrap_help (help
, opt
, len
, columns
);
1831 if (option
->var_type
== CLVC_ENUM
1832 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1833 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1836 vec
<const char *> option_values
1837 = targetm_common
.get_valid_option_values (i
, NULL
);
1838 if (!option_values
.is_empty ())
1839 help_tuples
.safe_push (option_help_tuple (i
, option_values
));
1845 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1848 printf (_(" No options with the desired characteristics were found\n"));
1853 /* PR 31349: Tell the user how to see all of the
1854 options supported by a specific front end. */
1855 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1856 if ((1U << i
) & langs
)
1857 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1858 lang_names
[i
], lang_names
[i
]);
1862 else if (! displayed
)
1863 printf (_(" All options with the desired characteristics have already been displayed\n"));
1867 /* Print details of enumerated option arguments, if those
1868 enumerations have help text headings provided. If no help text
1869 is provided, presume that the possible values are listed in the
1870 help text for the relevant options. */
1871 for (i
= 0; i
< cl_enums_count
; i
++)
1873 unsigned int j
, pos
;
1875 if (opts
->x_help_enum_printed
[i
] != 1)
1877 if (cl_enums
[i
].help
== NULL
)
1879 printf (" %s\n ", _(cl_enums
[i
].help
));
1881 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1883 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1885 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1887 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1897 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1902 opts
->x_help_enum_printed
[i
] = 2;
1905 for (unsigned i
= 0; i
< help_tuples
.length (); i
++)
1907 const struct cl_option
*option
= cl_options
+ help_tuples
[i
].m_code
;
1908 printf (_(" Known valid arguments for %s option:\n "),
1910 for (unsigned j
= 0; j
< help_tuples
[i
].m_values
.length (); j
++)
1911 printf (" %s", help_tuples
[i
].m_values
[j
]);
1916 /* Display help for a specified type of option.
1917 The options must have ALL of the INCLUDE_FLAGS set
1918 ANY of the flags in the ANY_FLAGS set
1919 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1920 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1922 print_specific_help (unsigned int include_flags
,
1923 unsigned int exclude_flags
,
1924 unsigned int any_flags
,
1925 struct gcc_options
*opts
,
1926 unsigned int lang_mask
)
1928 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1929 const char * description
= NULL
;
1930 const char * descrip_extra
= "";
1934 /* Sanity check: Make sure that we do not have more
1935 languages than we have bits available to enumerate them. */
1936 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1938 /* If we have not done so already, obtain
1939 the desired maximum width of the output. */
1940 if (opts
->x_help_columns
== 0)
1942 opts
->x_help_columns
= get_terminal_width ();
1943 if (opts
->x_help_columns
== INT_MAX
)
1944 /* Use a reasonable default. */
1945 opts
->x_help_columns
= 80;
1948 /* Decide upon the title for the options that we are going to display. */
1949 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1951 switch (flag
& include_flags
)
1958 description
= _("The following options are target specific");
1961 description
= _("The following options control compiler warning messages");
1963 case CL_OPTIMIZATION
:
1964 description
= _("The following options control optimizations");
1967 description
= _("The following options are language-independent");
1970 description
= _("The following options control parameters");
1973 if (i
>= cl_lang_count
)
1975 if (exclude_flags
& all_langs_mask
)
1976 description
= _("The following options are specific to just the language ");
1978 description
= _("The following options are supported by the language ");
1979 descrip_extra
= lang_names
[i
];
1984 if (description
== NULL
)
1988 if (include_flags
& CL_UNDOCUMENTED
)
1989 description
= _("The following options are not documented");
1990 else if (include_flags
& CL_SEPARATE
)
1991 description
= _("The following options take separate arguments");
1992 else if (include_flags
& CL_JOINED
)
1993 description
= _("The following options take joined arguments");
1996 internal_error ("unrecognized %<include_flags 0x%x%> passed "
1997 "to %<print_specific_help%>",
2004 if (any_flags
& all_langs_mask
)
2005 description
= _("The following options are language-related");
2007 description
= _("The following options are language-independent");
2011 printf ("%s%s:\n", description
, descrip_extra
);
2012 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
2013 opts
->x_help_columns
, opts
, lang_mask
);
2016 /* Enable FDO-related flags. */
2019 enable_fdo_optimizations (struct gcc_options
*opts
,
2020 struct gcc_options
*opts_set
,
2023 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_branch_probabilities
, value
);
2024 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
2025 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_loops
, value
);
2026 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_peel_loops
, value
);
2027 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tracer
, value
);
2028 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_value_profile_transformations
,
2030 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
2031 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp
, value
);
2034 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp_clone
, 1);
2035 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, 1);
2037 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_predictive_commoning
, value
);
2038 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_split_loops
, value
);
2039 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unswitch_loops
, value
);
2040 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_gcse_after_reload
, value
);
2041 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_vectorize
, value
);
2042 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_slp_vectorize
, value
);
2043 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_version_loops_for_strides
, value
);
2044 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_vect_cost_model
,
2045 VECT_COST_MODEL_DYNAMIC
);
2046 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribute_patterns
,
2048 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_loop_interchange
, value
);
2049 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_jam
, value
);
2050 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribution
, value
);
2053 /* -f{,no-}sanitize{,-recover}= suboptions. */
2054 const struct sanitizer_opts_s sanitizer_opts
[] =
2056 #define SANITIZER_OPT(name, flags, recover, trap) \
2057 { #name, flags, sizeof #name - 1, recover, trap }
2058 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true,
2060 SANITIZER_OPT (hwaddress
, (SANITIZE_HWADDRESS
| SANITIZE_USER_HWADDRESS
),
2062 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
2064 SANITIZER_OPT (kernel
-hwaddress
,
2065 (SANITIZE_HWADDRESS
| SANITIZE_KERNEL_HWADDRESS
),
2067 SANITIZER_OPT (pointer
-compare
, SANITIZE_POINTER_COMPARE
, true, false),
2068 SANITIZER_OPT (pointer
-subtract
, SANITIZE_POINTER_SUBTRACT
, true, false),
2069 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false, false),
2070 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false, false),
2071 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true, true),
2072 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true, true),
2073 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true, true),
2074 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true, true),
2075 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true, true),
2076 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false, true),
2077 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true, true),
2078 SANITIZER_OPT (return, SANITIZE_RETURN
, false, true),
2079 SANITIZER_OPT (null
, SANITIZE_NULL
, true, true),
2080 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true, true),
2081 SANITIZER_OPT (bool, SANITIZE_BOOL
, true, true),
2082 SANITIZER_OPT (enum, SANITIZE_ENUM
, true, true),
2083 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true, true),
2084 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true, true),
2085 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true, true),
2086 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true,
2088 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true, true),
2089 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true, true),
2090 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
2092 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true, true),
2093 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true, false),
2094 SANITIZER_OPT (pointer
-overflow
, SANITIZE_POINTER_OVERFLOW
, true, true),
2095 SANITIZER_OPT (builtin
, SANITIZE_BUILTIN
, true, true),
2096 SANITIZER_OPT (shadow
-call
-stack
, SANITIZE_SHADOW_CALL_STACK
, false, false),
2097 SANITIZER_OPT (all
, ~0U, true, true),
2098 #undef SANITIZER_OPT
2099 { NULL
, 0U, 0UL, false, false }
2102 /* -fzero-call-used-regs= suboptions. */
2103 const struct zero_call_used_regs_opts_s zero_call_used_regs_opts
[] =
2105 #define ZERO_CALL_USED_REGS_OPT(name, flags) \
2107 ZERO_CALL_USED_REGS_OPT (skip
, zero_regs_flags::SKIP
),
2108 ZERO_CALL_USED_REGS_OPT (used
-gpr
-arg
, zero_regs_flags::USED_GPR_ARG
),
2109 ZERO_CALL_USED_REGS_OPT (used
-gpr
, zero_regs_flags::USED_GPR
),
2110 ZERO_CALL_USED_REGS_OPT (used
-arg
, zero_regs_flags::USED_ARG
),
2111 ZERO_CALL_USED_REGS_OPT (used
, zero_regs_flags::USED
),
2112 ZERO_CALL_USED_REGS_OPT (all
-gpr
-arg
, zero_regs_flags::ALL_GPR_ARG
),
2113 ZERO_CALL_USED_REGS_OPT (all
-gpr
, zero_regs_flags::ALL_GPR
),
2114 ZERO_CALL_USED_REGS_OPT (all
-arg
, zero_regs_flags::ALL_ARG
),
2115 ZERO_CALL_USED_REGS_OPT (all
, zero_regs_flags::ALL
),
2116 #undef ZERO_CALL_USED_REGS_OPT
2120 /* A struct for describing a run of chars within a string. */
2122 class string_fragment
2125 string_fragment (const char *start
, size_t len
)
2126 : m_start (start
), m_len (len
) {}
2128 const char *m_start
;
2132 /* Specialization of edit_distance_traits for string_fragment,
2133 for use by get_closest_sanitizer_option. */
2136 struct edit_distance_traits
<const string_fragment
&>
2138 static size_t get_length (const string_fragment
&fragment
)
2140 return fragment
.m_len
;
2143 static const char *get_string (const string_fragment
&fragment
)
2145 return fragment
.m_start
;
2149 /* Given ARG, an unrecognized sanitizer option, return the best
2150 matching sanitizer option, or NULL if there isn't one.
2151 OPTS is array of candidate sanitizer options.
2152 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or OPT_fsanitize_trap_.
2153 VALUE is non-zero for the regular form of the option, zero
2154 for the "no-" form (e.g. "-fno-sanitize-recover="). */
2157 get_closest_sanitizer_option (const string_fragment
&arg
,
2158 const struct sanitizer_opts_s
*opts
,
2159 enum opt_code code
, int value
)
2161 best_match
<const string_fragment
&, const char*> bm (arg
);
2162 for (int i
= 0; opts
[i
].name
!= NULL
; ++i
)
2164 /* -fsanitize=all is not valid, so don't offer it. */
2165 if (code
== OPT_fsanitize_
2166 && opts
[i
].flag
== ~0U
2170 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
2171 don't offer the non-recoverable options. */
2172 if (code
== OPT_fsanitize_recover_
2173 && !opts
[i
].can_recover
2177 /* For -fsanitize-trap= (and not -fno-sanitize-trap=),
2178 don't offer the non-trapping options. */
2179 if (code
== OPT_fsanitize_trap_
2180 && !opts
[i
].can_trap
2184 bm
.consider (opts
[i
].name
);
2186 return bm
.get_best_meaningful_candidate ();
2189 /* Parse comma separated sanitizer suboptions from P for option SCODE,
2190 adjust previous FLAGS and return new ones. If COMPLAIN is false,
2191 don't issue diagnostics. */
2194 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
2195 unsigned int flags
, int value
, bool complain
)
2197 enum opt_code code
= (enum opt_code
) scode
;
2203 const char *comma
= strchr (p
, ',');
2215 /* Check to see if the string matches an option class name. */
2216 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
2217 if (len
== sanitizer_opts
[i
].len
2218 && memcmp (p
, sanitizer_opts
[i
].name
, len
) == 0)
2220 /* Handle both -fsanitize and -fno-sanitize cases. */
2221 if (value
&& sanitizer_opts
[i
].flag
== ~0U)
2223 if (code
== OPT_fsanitize_
)
2226 error_at (loc
, "%<-fsanitize=all%> option is not valid");
2228 else if (code
== OPT_fsanitize_recover_
)
2229 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
2230 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
2231 | SANITIZE_SHADOW_CALL_STACK
);
2232 else /* if (code == OPT_fsanitize_trap_) */
2233 flags
|= (SANITIZE_UNDEFINED
2234 | SANITIZE_UNDEFINED_NONDEFAULT
);
2238 /* Do not enable -fsanitize-recover=unreachable and
2239 -fsanitize-recover=return if -fsanitize-recover=undefined
2241 if (code
== OPT_fsanitize_recover_
2242 && sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
2243 flags
|= (SANITIZE_UNDEFINED
2244 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
2245 else if (code
== OPT_fsanitize_trap_
2246 && sanitizer_opts
[i
].flag
== SANITIZE_VPTR
)
2247 error_at (loc
, "%<-fsanitize-trap=%s%> is not supported",
2248 sanitizer_opts
[i
].name
);
2250 flags
|= sanitizer_opts
[i
].flag
;
2254 flags
&= ~sanitizer_opts
[i
].flag
;
2255 /* Don't always clear SANITIZE_ADDRESS if it was previously
2256 set: -fsanitize=address -fno-sanitize=kernel-address should
2257 leave SANITIZE_ADDRESS set. */
2258 if (flags
& (SANITIZE_KERNEL_ADDRESS
| SANITIZE_USER_ADDRESS
))
2259 flags
|= SANITIZE_ADDRESS
;
2265 if (! found
&& complain
)
2268 = get_closest_sanitizer_option (string_fragment (p
, len
),
2269 sanitizer_opts
, code
, value
);
2272 if (code
== OPT_fsanitize_recover_
)
2273 suffix
= "-recover";
2274 else if (code
== OPT_fsanitize_trap_
)
2281 "unrecognized argument to %<-f%ssanitize%s=%> "
2282 "option: %q.*s; did you mean %qs?",
2284 suffix
, (int) len
, p
, hint
);
2287 "unrecognized argument to %<-f%ssanitize%s=%> option: "
2288 "%q.*s", value
? "" : "no-",
2289 suffix
, (int) len
, p
);
2299 /* Parse string values of no_sanitize attribute passed in VALUE.
2300 Values are separated with comma. */
2303 parse_no_sanitize_attribute (char *value
)
2305 unsigned int flags
= 0;
2307 char *q
= strtok (value
, ",");
2311 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
2312 if (strcmp (sanitizer_opts
[i
].name
, q
) == 0)
2314 flags
|= sanitizer_opts
[i
].flag
;
2315 if (sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
2316 flags
|= SANITIZE_UNDEFINED_NONDEFAULT
;
2320 if (sanitizer_opts
[i
].name
== NULL
)
2321 warning (OPT_Wattributes
,
2322 "%qs attribute directive ignored", q
);
2324 q
= strtok (NULL
, ",");
2330 /* Parse -fzero-call-used-regs suboptions from ARG, return the FLAGS. */
2333 parse_zero_call_used_regs_options (const char *arg
)
2335 unsigned int flags
= 0;
2337 /* Check to see if the string matches a sub-option name. */
2338 for (unsigned int i
= 0; zero_call_used_regs_opts
[i
].name
!= NULL
; ++i
)
2339 if (strcmp (arg
, zero_call_used_regs_opts
[i
].name
) == 0)
2341 flags
= zero_call_used_regs_opts
[i
].flag
;
2346 error ("unrecognized argument to %<-fzero-call-used-regs=%>: %qs", arg
);
2351 /* Parse -falign-NAME format for a FLAG value. Return individual
2352 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
2353 set, print error message at LOC location. */
2356 parse_and_check_align_values (const char *flag
,
2358 auto_vec
<unsigned> &result_values
,
2362 char *str
= xstrdup (flag
);
2363 for (char *p
= strtok (str
, ":"); p
; p
= strtok (NULL
, ":"))
2366 int v
= strtol (p
, &end
, 10);
2367 if (*end
!= '\0' || v
< 0)
2370 error_at (loc
, "invalid arguments for %<-falign-%s%> option: %qs",
2376 result_values
.safe_push ((unsigned)v
);
2381 /* Check that we have a correct number of values. */
2382 if (result_values
.is_empty () || result_values
.length () > 4)
2385 error_at (loc
, "invalid number of arguments for %<-falign-%s%> "
2386 "option: %qs", name
, flag
);
2390 for (unsigned i
= 0; i
< result_values
.length (); i
++)
2391 if (result_values
[i
] > MAX_CODE_ALIGN_VALUE
)
2394 error_at (loc
, "%<-falign-%s%> is not between 0 and %d",
2395 name
, MAX_CODE_ALIGN_VALUE
);
2402 /* Check that alignment value FLAG for -falign-NAME is valid at a given
2403 location LOC. OPT_STR points to the stored -falign-NAME=argument and
2404 OPT_FLAG points to the associated -falign-NAME on/off flag. */
2407 check_alignment_argument (location_t loc
, const char *flag
, const char *name
,
2408 int *opt_flag
, const char **opt_str
)
2410 auto_vec
<unsigned> align_result
;
2411 parse_and_check_align_values (flag
, name
, align_result
, true, loc
);
2413 if (align_result
.length() >= 1 && align_result
[0] == 0)
2420 /* Parse argument of -fpatchable-function-entry option ARG and store
2421 corresponding values to PATCH_AREA_SIZE and PATCH_AREA_START.
2422 If REPORT_ERROR is set to true, generate error for a problematic
2423 option arguments. */
2426 parse_and_check_patch_area (const char *arg
, bool report_error
,
2427 HOST_WIDE_INT
*patch_area_size
,
2428 HOST_WIDE_INT
*patch_area_start
)
2430 *patch_area_size
= 0;
2431 *patch_area_start
= 0;
2436 char *patch_area_arg
= xstrdup (arg
);
2437 char *comma
= strchr (patch_area_arg
, ',');
2441 *patch_area_size
= integral_argument (patch_area_arg
);
2442 *patch_area_start
= integral_argument (comma
+ 1);
2445 *patch_area_size
= integral_argument (patch_area_arg
);
2447 if (*patch_area_size
< 0
2448 || *patch_area_size
> USHRT_MAX
2449 || *patch_area_start
< 0
2450 || *patch_area_start
> USHRT_MAX
2451 || *patch_area_size
< *patch_area_start
)
2453 error ("invalid arguments for %<-fpatchable-function-entry%>");
2455 free (patch_area_arg
);
2458 /* Print help when OPT__help_ is set. */
2461 print_help (struct gcc_options
*opts
, unsigned int lang_mask
,
2462 const char *help_option_argument
)
2464 const char *a
= help_option_argument
;
2465 unsigned int include_flags
= 0;
2466 /* Note - by default we include undocumented options when listing
2467 specific classes. If you only want to see documented options
2468 then add ",^undocumented" to the --help= option. E.g.:
2470 --help=target,^undocumented */
2471 unsigned int exclude_flags
= 0;
2473 if (lang_mask
== CL_DRIVER
)
2476 /* Walk along the argument string, parsing each word in turn.
2478 arg = [^]{word}[,{arg}]
2479 word = {optimizers|target|warnings|undocumented|
2480 params|common|<language>} */
2490 { "optimizers", CL_OPTIMIZATION
},
2491 { "target", CL_TARGET
},
2492 { "warnings", CL_WARNING
},
2493 { "undocumented", CL_UNDOCUMENTED
},
2494 { "params", CL_PARAMS
},
2495 { "joined", CL_JOINED
},
2496 { "separate", CL_SEPARATE
},
2497 { "common", CL_COMMON
},
2500 unsigned int *pflags
;
2502 unsigned int lang_flag
, specific_flag
;
2511 error ("missing argument to %qs", "--help=^");
2514 pflags
= &exclude_flags
;
2517 pflags
= &include_flags
;
2519 comma
= strchr (a
, ',');
2530 /* Check to see if the string matches an option class name. */
2531 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
2532 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
2534 specific_flag
= specifics
[i
].flag
;
2538 /* Check to see if the string matches a language name.
2539 Note - we rely upon the alpha-sorted nature of the entries in
2540 the lang_names array, specifically that shorter names appear
2541 before their longer variants. (i.e. C before C++). That way
2542 when we are attempting to match --help=c for example we will
2543 match with C first and not C++. */
2544 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
2545 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
2547 lang_flag
= 1U << i
;
2551 if (specific_flag
!= 0)
2554 *pflags
|= specific_flag
;
2557 /* The option's argument matches both the start of a
2558 language name and the start of an option class name.
2559 We have a special case for when the user has
2560 specified "--help=c", but otherwise we have to issue
2562 if (strncasecmp (a
, "c", len
) == 0)
2563 *pflags
|= lang_flag
;
2566 "%<--help%> argument %q.*s is ambiguous, "
2567 "please be more specific",
2571 else if (lang_flag
!= 0)
2572 *pflags
|= lang_flag
;
2575 "unrecognized argument to %<--help=%> option: %q.*s",
2583 /* We started using PerFunction/Optimization for parameters and
2584 a warning. We should exclude these from optimization options. */
2585 if (include_flags
& CL_OPTIMIZATION
)
2586 exclude_flags
|= CL_WARNING
;
2587 if (!(include_flags
& CL_PARAMS
))
2588 exclude_flags
|= CL_PARAMS
;
2591 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
2595 /* Handle target- and language-independent options. Return zero to
2596 generate an "unknown option" message. Only options that need
2597 extra handling need to be listed here; if you simply want
2598 DECODED->value assigned to a variable, it happens automatically. */
2601 common_handle_option (struct gcc_options
*opts
,
2602 struct gcc_options
*opts_set
,
2603 const struct cl_decoded_option
*decoded
,
2604 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
2606 const struct cl_option_handlers
*handlers
,
2607 diagnostic_context
*dc
,
2608 void (*target_option_override_hook
) (void))
2610 size_t scode
= decoded
->opt_index
;
2611 const char *arg
= decoded
->arg
;
2612 HOST_WIDE_INT value
= decoded
->value
;
2613 enum opt_code code
= (enum opt_code
) scode
;
2615 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
2621 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
2622 unsigned int undoc_mask
;
2625 if (lang_mask
== CL_DRIVER
)
2628 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
2631 target_option_override_hook ();
2632 /* First display any single language specific options. */
2633 for (i
= 0; i
< cl_lang_count
; i
++)
2635 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
2637 /* Next display any multi language specific options. */
2638 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
2639 /* Then display any remaining, non-language options. */
2640 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
2642 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
2643 opts
->x_exit_after_options
= true;
2647 case OPT__target_help
:
2648 if (lang_mask
== CL_DRIVER
)
2651 target_option_override_hook ();
2652 print_specific_help (CL_TARGET
, 0, 0, opts
, lang_mask
);
2653 opts
->x_exit_after_options
= true;
2658 help_option_arguments
.safe_push (arg
);
2659 opts
->x_exit_after_options
= true;
2664 if (lang_mask
== CL_DRIVER
)
2667 opts
->x_exit_after_options
= true;
2670 case OPT__completion_
:
2673 case OPT_fsanitize_
:
2674 opts_set
->x_flag_sanitize
= true;
2675 opts
->x_flag_sanitize
2676 = parse_sanitizer_options (arg
, loc
, code
,
2677 opts
->x_flag_sanitize
, value
, true);
2679 /* Kernel ASan implies normal ASan but does not yet support
2681 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
2683 SET_OPTION_IF_UNSET (opts
, opts_set
,
2684 param_asan_instrumentation_with_call_threshold
,
2686 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_globals
, 0);
2687 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_stack
, 0);
2688 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_protect_allocas
, 0);
2689 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_use_after_return
, 0);
2691 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_HWADDRESS
)
2693 SET_OPTION_IF_UNSET (opts
, opts_set
,
2694 param_hwasan_instrument_stack
, 0);
2695 SET_OPTION_IF_UNSET (opts
, opts_set
,
2696 param_hwasan_random_frame_tag
, 0);
2697 SET_OPTION_IF_UNSET (opts
, opts_set
,
2698 param_hwasan_instrument_allocas
, 0);
2702 case OPT_fsanitize_recover_
:
2703 opts
->x_flag_sanitize_recover
2704 = parse_sanitizer_options (arg
, loc
, code
,
2705 opts
->x_flag_sanitize_recover
, value
, true);
2708 case OPT_fsanitize_trap_
:
2709 opts
->x_flag_sanitize_trap
2710 = parse_sanitizer_options (arg
, loc
, code
,
2711 opts
->x_flag_sanitize_trap
, value
, true);
2714 case OPT_fasan_shadow_offset_
:
2718 case OPT_fsanitize_address_use_after_scope
:
2719 opts
->x_flag_sanitize_address_use_after_scope
= value
;
2722 case OPT_fsanitize_recover
:
2724 opts
->x_flag_sanitize_recover
2725 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)
2726 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2728 opts
->x_flag_sanitize_recover
2729 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2732 case OPT_fsanitize_trap
:
2734 opts
->x_flag_sanitize_trap
2735 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2737 opts
->x_flag_sanitize_trap
2738 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2746 /* Currently handled in a prescan. */
2749 case OPT_Wattributes_
:
2750 if (lang_mask
== CL_DRIVER
)
2755 error_at (loc
, "arguments ignored for %<-Wattributes=%>; use "
2756 "%<-Wno-attributes=%> instead");
2759 else if (arg
[strlen (arg
) - 1] == ',')
2761 error_at (loc
, "trailing %<,%> in arguments for "
2762 "%<-Wno-attributes=%>");
2766 add_comma_separated_to_vector (&opts
->x_flag_ignored_attributes
, arg
);
2770 dc
->warning_as_error_requested
= value
;
2774 if (lang_mask
== CL_DRIVER
)
2777 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
2778 opts
, opts_set
, loc
, dc
);
2781 case OPT_Wfatal_errors
:
2782 dc
->fatal_errors
= value
;
2785 case OPT_Wstack_usage_
:
2786 opts
->x_flag_stack_usage_info
= value
!= -1;
2789 case OPT_Wstrict_aliasing
:
2790 set_Wstrict_aliasing (opts
, value
);
2793 case OPT_Wstrict_overflow
:
2794 opts
->x_warn_strict_overflow
= (value
2795 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2799 case OPT_Wsystem_headers
:
2800 dc
->dc_warn_system_headers
= value
;
2804 opts
->x_flag_gen_aux_info
= 1;
2808 decode_d_option (arg
, opts
, loc
, dc
);
2811 case OPT_fcall_used_
:
2812 case OPT_fcall_saved_
:
2820 case OPT_fdebug_prefix_map_
:
2821 case OPT_ffile_prefix_map_
:
2822 case OPT_fprofile_prefix_map_
:
2826 case OPT_fcanon_prefix_map
:
2827 flag_canon_prefix_map
= value
;
2830 case OPT_fcallgraph_info
:
2831 opts
->x_flag_callgraph_info
= CALLGRAPH_INFO_NAKED
;
2834 case OPT_fcallgraph_info_
:
2837 my_arg
= xstrdup (arg
);
2838 p
= strtok (my_arg
, ",");
2841 if (strcmp (p
, "su") == 0)
2843 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_STACK_USAGE
;
2844 opts
->x_flag_stack_usage_info
= true;
2846 else if (strcmp (p
, "da") == 0)
2847 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_DYNAMIC_ALLOC
;
2850 p
= strtok (NULL
, ",");
2856 case OPT_fdiagnostics_show_location_
:
2857 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2860 case OPT_fdiagnostics_show_caret
:
2861 dc
->show_caret
= value
;
2864 case OPT_fdiagnostics_show_labels
:
2865 dc
->show_labels_p
= value
;
2868 case OPT_fdiagnostics_show_line_numbers
:
2869 dc
->show_line_numbers_p
= value
;
2872 case OPT_fdiagnostics_color_
:
2873 diagnostic_color_init (dc
, value
);
2876 case OPT_fdiagnostics_urls_
:
2877 diagnostic_urls_init (dc
, value
);
2880 case OPT_fdiagnostics_format_
:
2882 const char *basename
= (opts
->x_dump_base_name
? opts
->x_dump_base_name
2883 : opts
->x_main_input_basename
);
2884 diagnostic_output_format_init (dc
, basename
,
2885 (enum diagnostics_output_format
)value
);
2889 case OPT_fdiagnostics_parseable_fixits
:
2890 dc
->extra_output_kind
= (value
2891 ? EXTRA_DIAGNOSTIC_OUTPUT_fixits_v1
2892 : EXTRA_DIAGNOSTIC_OUTPUT_none
);
2895 case OPT_fdiagnostics_column_unit_
:
2896 dc
->column_unit
= (enum diagnostics_column_unit
)value
;
2899 case OPT_fdiagnostics_column_origin_
:
2900 dc
->column_origin
= value
;
2903 case OPT_fdiagnostics_escape_format_
:
2904 dc
->escape_format
= (enum diagnostics_escape_format
)value
;
2907 case OPT_fdiagnostics_show_cwe
:
2908 dc
->show_cwe
= value
;
2911 case OPT_fdiagnostics_show_rules
:
2912 dc
->show_rules
= value
;
2915 case OPT_fdiagnostics_path_format_
:
2916 dc
->path_format
= (enum diagnostic_path_format
)value
;
2919 case OPT_fdiagnostics_show_path_depths
:
2920 dc
->show_path_depths
= value
;
2923 case OPT_fdiagnostics_show_option
:
2924 dc
->show_option_requested
= value
;
2927 case OPT_fdiagnostics_minimum_margin_width_
:
2928 dc
->min_margin_width
= value
;
2935 case OPT_ffast_math
:
2936 set_fast_math_flags (opts
, value
);
2939 case OPT_funsafe_math_optimizations
:
2940 set_unsafe_math_optimizations_flags (opts
, value
);
2947 case OPT_finline_limit_
:
2948 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_single
,
2950 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_auto
,
2954 case OPT_finstrument_functions_exclude_function_list_
:
2955 add_comma_separated_to_vector
2956 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2959 case OPT_finstrument_functions_exclude_file_list_
:
2960 add_comma_separated_to_vector
2961 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2964 case OPT_fmessage_length_
:
2965 pp_set_line_maximum_length (dc
->printer
, value
);
2966 diagnostic_set_caret_max_width (dc
, value
);
2970 case OPT_fopt_info_
:
2974 case OPT_foffload_options_
:
2978 case OPT_foffload_abi_
:
2979 #ifdef ACCEL_COMPILER
2980 /* Handled in the 'mkoffload's. */
2982 error_at (loc
, "%<-foffload-abi%> option can be specified only for "
2983 "offload compiler");
2987 case OPT_fpack_struct_
:
2988 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2990 "structure alignment must be a small power of two, not %wu",
2993 opts
->x_initial_max_fld_align
= value
;
2997 case OPT_fplugin_arg_
:
3001 case OPT_fprofile_use_
:
3002 opts
->x_profile_data_prefix
= xstrdup (arg
);
3003 opts
->x_flag_profile_use
= true;
3005 /* No break here - do -fprofile-use processing. */
3007 case OPT_fprofile_use
:
3008 enable_fdo_optimizations (opts
, opts_set
, value
);
3009 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_reorder_functions
,
3011 /* Indirect call profiling should do all useful transformations
3012 speculative devirtualization does. */
3013 if (opts
->x_flag_value_profile_transformations
)
3014 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_devirtualize_speculatively
,
3018 case OPT_fauto_profile_
:
3019 opts
->x_auto_profile_file
= xstrdup (arg
);
3020 opts
->x_flag_auto_profile
= true;
3022 /* No break here - do -fauto-profile processing. */
3024 case OPT_fauto_profile
:
3025 enable_fdo_optimizations (opts
, opts_set
, value
);
3026 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_correction
, value
);
3029 case OPT_fprofile_generate_
:
3030 opts
->x_profile_data_prefix
= xstrdup (arg
);
3032 /* No break here - do -fprofile-generate processing. */
3034 case OPT_fprofile_generate
:
3035 SET_OPTION_IF_UNSET (opts
, opts_set
, profile_arc_flag
, value
);
3036 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
3037 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
3038 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, value
);
3041 case OPT_fprofile_info_section
:
3042 opts
->x_profile_info_section
= ".gcov_info";
3045 case OPT_fpatchable_function_entry_
:
3047 HOST_WIDE_INT patch_area_size
, patch_area_start
;
3048 parse_and_check_patch_area (arg
, true, &patch_area_size
,
3053 case OPT_ftree_vectorize
:
3054 /* Automatically sets -ftree-loop-vectorize and
3055 -ftree-slp-vectorize. Nothing more to do here. */
3057 case OPT_fzero_call_used_regs_
:
3058 opts
->x_flag_zero_call_used_regs
3059 = parse_zero_call_used_regs_options (arg
);
3062 case OPT_fshow_column
:
3063 dc
->show_column
= value
;
3066 case OPT_frandom_seed
:
3067 /* The real switch is -fno-random-seed. */
3073 case OPT_frandom_seed_
:
3077 case OPT_fsched_verbose_
:
3078 #ifdef INSN_SCHEDULING
3079 /* Handled with Var in common.opt. */
3085 case OPT_fsched_stalled_insns_
:
3086 opts
->x_flag_sched_stalled_insns
= value
;
3087 if (opts
->x_flag_sched_stalled_insns
== 0)
3088 opts
->x_flag_sched_stalled_insns
= -1;
3091 case OPT_fsched_stalled_insns_dep_
:
3092 opts
->x_flag_sched_stalled_insns_dep
= value
;
3095 case OPT_fstack_check_
:
3096 if (!strcmp (arg
, "no"))
3097 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
3098 else if (!strcmp (arg
, "generic"))
3099 /* This is the old stack checking method. */
3100 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
3101 ? FULL_BUILTIN_STACK_CHECK
3102 : GENERIC_STACK_CHECK
;
3103 else if (!strcmp (arg
, "specific"))
3104 /* This is the new stack checking method. */
3105 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
3106 ? FULL_BUILTIN_STACK_CHECK
3107 : STACK_CHECK_STATIC_BUILTIN
3108 ? STATIC_BUILTIN_STACK_CHECK
3109 : GENERIC_STACK_CHECK
;
3111 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
3114 case OPT_fstack_limit
:
3115 /* The real switch is -fno-stack-limit. */
3121 case OPT_fstack_limit_register_
:
3122 case OPT_fstack_limit_symbol_
:
3126 case OPT_fstack_usage
:
3127 opts
->x_flag_stack_usage
= value
;
3128 opts
->x_flag_stack_usage_info
= value
!= 0;
3132 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
3137 set_debug_level (BTF_DEBUG
, false, arg
, opts
, opts_set
, loc
);
3138 /* set the debug level to level 2, but if already at level 3,
3140 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
3141 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3145 set_debug_level (CTF_DEBUG
, false, arg
, opts
, opts_set
, loc
);
3146 /* CTF generation feeds off DWARF dies. For optimal CTF, switch debug
3147 info level to 2. If off or at level 1, set it to level 2, but if
3148 already at level 3, don't lower it. */
3149 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
3150 && opts
->x_ctf_debug_info_level
> CTFINFO_LEVEL_NONE
)
3151 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3155 if (arg
&& strlen (arg
) != 0)
3157 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
3158 "use %<-gdwarf-%s%> for DWARF version "
3159 "or %<-gdwarf%> %<-g%s%> for debug level", arg
, arg
, arg
);
3163 value
= opts
->x_dwarf_version
;
3167 if (value
< 2 || value
> 5)
3168 error_at (loc
, "dwarf version %wu is not supported", value
);
3170 opts
->x_dwarf_version
= value
;
3171 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
3175 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
3179 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
3184 /* Handled completely via specs. */
3187 case OPT_pedantic_errors
:
3188 dc
->pedantic_errors
= 1;
3189 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
3191 handlers
, opts
, opts_set
,
3196 opts
->x_flag_lto
= value
? "" : NULL
;
3200 if (strcmp (arg
, "none") != 0
3201 && strcmp (arg
, "jobserver") != 0
3202 && strcmp (arg
, "auto") != 0
3205 "unrecognized argument to %<-flto=%> option: %qs", arg
);
3209 dc
->dc_inhibit_warnings
= true;
3212 case OPT_fmax_errors_
:
3213 dc
->max_errors
= value
;
3216 case OPT_fuse_ld_bfd
:
3217 case OPT_fuse_ld_gold
:
3218 case OPT_fuse_ld_lld
:
3219 case OPT_fuse_ld_mold
:
3220 case OPT_fuse_linker_plugin
:
3221 /* No-op. Used by the driver and passed to us because it starts with f.*/
3226 opts
->x_flag_trapv
= 0;
3231 opts
->x_flag_wrapv
= 0;
3234 case OPT_fstrict_overflow
:
3235 opts
->x_flag_wrapv
= !value
;
3236 opts
->x_flag_wrapv_pointer
= !value
;
3238 opts
->x_flag_trapv
= 0;
3242 opts
->x_flag_ipa_icf_functions
= value
;
3243 opts
->x_flag_ipa_icf_variables
= value
;
3246 case OPT_falign_loops_
:
3247 check_alignment_argument (loc
, arg
, "loops",
3248 &opts
->x_flag_align_loops
,
3249 &opts
->x_str_align_loops
);
3252 case OPT_falign_jumps_
:
3253 check_alignment_argument (loc
, arg
, "jumps",
3254 &opts
->x_flag_align_jumps
,
3255 &opts
->x_str_align_jumps
);
3258 case OPT_falign_labels_
:
3259 check_alignment_argument (loc
, arg
, "labels",
3260 &opts
->x_flag_align_labels
,
3261 &opts
->x_str_align_labels
);
3264 case OPT_falign_functions_
:
3265 check_alignment_argument (loc
, arg
, "functions",
3266 &opts
->x_flag_align_functions
,
3267 &opts
->x_str_align_functions
);
3271 /* It is documented that we silently ignore silly values. */
3272 if (value
>= 1 && value
<= 100)
3273 dc
->tabstop
= value
;
3276 case OPT_freport_bug
:
3277 dc
->report_bug
= value
;
3280 case OPT_fmultiflags
:
3281 gcc_checking_assert (lang_mask
== CL_DRIVER
);
3285 /* If the flag was handled in a standard way, assume the lack of
3286 processing here is intentional. */
3287 gcc_assert (option_flag_var (scode
, opts
));
3291 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
3296 /* Used to set the level of strict aliasing warnings in OPTS,
3297 when no level is specified (i.e., when -Wstrict-aliasing, and not
3298 -Wstrict-aliasing=level was given).
3299 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
3300 and 0 otherwise. After calling this function, wstrict_aliasing will be
3301 set to the default value of -Wstrict_aliasing=level, currently 3. */
3303 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
3305 gcc_assert (onoff
== 0 || onoff
== 1);
3307 opts
->x_warn_strict_aliasing
= 3;
3309 opts
->x_warn_strict_aliasing
= 0;
3312 /* The following routines are useful in setting all the flags that
3313 -ffast-math and -fno-fast-math imply. */
3315 set_fast_math_flags (struct gcc_options
*opts
, int set
)
3317 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
3319 opts
->x_flag_unsafe_math_optimizations
= set
;
3320 set_unsafe_math_optimizations_flags (opts
, set
);
3322 if (!opts
->frontend_set_flag_finite_math_only
)
3323 opts
->x_flag_finite_math_only
= set
;
3324 if (!opts
->frontend_set_flag_errno_math
)
3325 opts
->x_flag_errno_math
= !set
;
3328 if (opts
->frontend_set_flag_excess_precision
== EXCESS_PRECISION_DEFAULT
)
3329 opts
->x_flag_excess_precision
3330 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
3331 if (!opts
->frontend_set_flag_signaling_nans
)
3332 opts
->x_flag_signaling_nans
= 0;
3333 if (!opts
->frontend_set_flag_rounding_math
)
3334 opts
->x_flag_rounding_math
= 0;
3335 if (!opts
->frontend_set_flag_cx_limited_range
)
3336 opts
->x_flag_cx_limited_range
= 1;
3340 /* When -funsafe-math-optimizations is set the following
3341 flags are set as well. */
3343 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
3345 if (!opts
->frontend_set_flag_trapping_math
)
3346 opts
->x_flag_trapping_math
= !set
;
3347 if (!opts
->frontend_set_flag_signed_zeros
)
3348 opts
->x_flag_signed_zeros
= !set
;
3349 if (!opts
->frontend_set_flag_associative_math
)
3350 opts
->x_flag_associative_math
= set
;
3351 if (!opts
->frontend_set_flag_reciprocal_math
)
3352 opts
->x_flag_reciprocal_math
= set
;
3355 /* Return true iff flags in OPTS are set as if -ffast-math. */
3357 fast_math_flags_set_p (const struct gcc_options
*opts
)
3359 return (!opts
->x_flag_trapping_math
3360 && opts
->x_flag_unsafe_math_optimizations
3361 && opts
->x_flag_finite_math_only
3362 && !opts
->x_flag_signed_zeros
3363 && !opts
->x_flag_errno_math
3364 && opts
->x_flag_excess_precision
== EXCESS_PRECISION_FAST
);
3367 /* Return true iff flags are set as if -ffast-math but using the flags stored
3368 in the struct cl_optimization structure. */
3370 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
3372 return (!opt
->x_flag_trapping_math
3373 && opt
->x_flag_unsafe_math_optimizations
3374 && opt
->x_flag_finite_math_only
3375 && !opt
->x_flag_signed_zeros
3376 && !opt
->x_flag_errno_math
);
3379 /* Handle a debug output -g switch for options OPTS
3380 (OPTS_SET->x_write_symbols storing whether a debug format was passed
3381 explicitly), location LOC. EXTENDED is true or false to support
3382 extended output (2 is special and means "-ggdb" was given). */
3384 set_debug_level (uint32_t dinfo
, int extended
, const char *arg
,
3385 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
3388 if (dinfo
== NO_DEBUG
)
3390 if (opts
->x_write_symbols
== NO_DEBUG
)
3392 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
3396 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
3397 if (opts
->x_write_symbols
& CTF_DEBUG
)
3398 opts
->x_write_symbols
|= DWARF2_DEBUG
;
3400 opts
->x_write_symbols
= DWARF2_DEBUG
;
3404 if (opts
->x_write_symbols
== NO_DEBUG
)
3405 warning_at (loc
, 0, "target system does not support debug output");
3407 else if ((opts
->x_write_symbols
& CTF_DEBUG
)
3408 || (opts
->x_write_symbols
& BTF_DEBUG
))
3410 opts
->x_write_symbols
|= DWARF2_DEBUG
;
3411 opts_set
->x_write_symbols
|= DWARF2_DEBUG
;
3416 /* Make and retain the choice if both CTF and DWARF debug info are to
3418 if (((dinfo
== DWARF2_DEBUG
) || (dinfo
== CTF_DEBUG
))
3419 && ((opts
->x_write_symbols
== (DWARF2_DEBUG
|CTF_DEBUG
))
3420 || (opts
->x_write_symbols
== DWARF2_DEBUG
)
3421 || (opts
->x_write_symbols
== CTF_DEBUG
)))
3423 opts
->x_write_symbols
|= dinfo
;
3424 opts_set
->x_write_symbols
|= dinfo
;
3426 /* However, CTF and BTF are not allowed together at this time. */
3427 else if (((dinfo
== DWARF2_DEBUG
) || (dinfo
== BTF_DEBUG
))
3428 && ((opts
->x_write_symbols
== (DWARF2_DEBUG
|BTF_DEBUG
))
3429 || (opts
->x_write_symbols
== DWARF2_DEBUG
)
3430 || (opts
->x_write_symbols
== BTF_DEBUG
)))
3432 opts
->x_write_symbols
|= dinfo
;
3433 opts_set
->x_write_symbols
|= dinfo
;
3437 /* Does it conflict with an already selected debug format? */
3438 if (opts_set
->x_write_symbols
!= NO_DEBUG
3439 && opts
->x_write_symbols
!= NO_DEBUG
3440 && dinfo
!= opts
->x_write_symbols
)
3442 gcc_assert (debug_set_count (dinfo
) <= 1);
3443 error_at (loc
, "debug format %qs conflicts with prior selection",
3444 debug_type_names
[debug_set_to_format (dinfo
)]);
3446 opts
->x_write_symbols
= dinfo
;
3447 opts_set
->x_write_symbols
= dinfo
;
3451 if (dinfo
!= BTF_DEBUG
)
3453 /* A debug flag without a level defaults to level 2.
3454 If off or at level 1, set it to level 2, but if already
3455 at level 3, don't lower it. */
3458 if (dinfo
== CTF_DEBUG
)
3459 opts
->x_ctf_debug_info_level
= CTFINFO_LEVEL_NORMAL
;
3460 else if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
3461 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3465 int argval
= integral_argument (arg
);
3467 error_at (loc
, "unrecognized debug output level %qs", arg
);
3468 else if (argval
> 3)
3469 error_at (loc
, "debug output level %qs is too high", arg
);
3472 if (dinfo
== CTF_DEBUG
)
3473 opts
->x_ctf_debug_info_level
3474 = (enum ctf_debug_info_levels
) argval
;
3476 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
3480 else if (*arg
!= '\0')
3481 error_at (loc
, "unrecognized btf debug output level %qs", arg
);
3484 /* Arrange to dump core on error for diagnostic context DC. (The
3485 regular error message is still printed first, except in the case of
3489 setup_core_dumping (diagnostic_context
*dc
)
3492 signal (SIGABRT
, SIG_DFL
);
3494 #if defined(HAVE_SETRLIMIT)
3497 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
3498 fatal_error (input_location
, "getting core file size maximum limit: %m");
3499 rlim
.rlim_cur
= rlim
.rlim_max
;
3500 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
3501 fatal_error (input_location
,
3502 "setting core file size limit to maximum: %m");
3505 diagnostic_abort_on_error (dc
);
3508 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
3509 diagnostic context DC. */
3512 decode_d_option (const char *arg
, struct gcc_options
*opts
,
3513 location_t loc
, diagnostic_context
*dc
)
3521 opts
->x_flag_debug_asm
= 1;
3524 opts
->x_flag_print_asm_name
= 1;
3527 opts
->x_flag_dump_rtl_in_asm
= 1;
3528 opts
->x_flag_print_asm_name
= 1;
3531 opts
->x_rtl_dump_and_exit
= 1;
3533 case 'D': /* These are handled by the preprocessor. */
3540 setup_core_dumping (dc
);
3543 opts
->x_flag_dump_all_passed
= true;
3547 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
3552 /* Enable (or disable if VALUE is 0) a warning option ARG (language
3553 mask LANG_MASK, option handlers HANDLERS) as an error for option
3554 structures OPTS and OPTS_SET, diagnostic context DC (possibly
3555 NULL), location LOC. This is used by -Werror=. */
3558 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
3559 const struct cl_option_handlers
*handlers
,
3560 struct gcc_options
*opts
,
3561 struct gcc_options
*opts_set
,
3562 location_t loc
, diagnostic_context
*dc
)
3567 new_option
= XNEWVEC (char, strlen (arg
) + 2);
3568 new_option
[0] = 'W';
3569 strcpy (new_option
+ 1, arg
);
3570 option_index
= find_opt (new_option
, lang_mask
);
3571 if (option_index
== OPT_SPECIAL_unknown
)
3574 const char *hint
= op
.suggest_option (new_option
);
3576 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>;"
3577 " did you mean %<-%s%>?", value
? "" : "no-",
3578 arg
, new_option
, hint
);
3580 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>",
3581 value
? "" : "no-", arg
, new_option
);
3583 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
3584 error_at (loc
, "%<-Werror=%s%>: %<-%s%> is not an option that "
3585 "controls warnings", arg
, new_option
);
3588 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
3589 const char *arg
= NULL
;
3591 if (cl_options
[option_index
].flags
& CL_JOINED
)
3592 arg
= new_option
+ cl_options
[option_index
].opt_len
;
3593 control_warning_option (option_index
, (int) kind
, arg
, value
,
3595 handlers
, opts
, opts_set
, dc
);
3600 /* Return malloced memory for the name of the option OPTION_INDEX
3601 which enabled a diagnostic (context CONTEXT), originally of type
3602 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
3606 option_name (diagnostic_context
*context
, int option_index
,
3607 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
3611 /* A warning classified as an error. */
3612 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
3613 && diag_kind
== DK_ERROR
)
3614 return concat (cl_options
[OPT_Werror_
].opt_text
,
3615 /* Skip over "-W". */
3616 cl_options
[option_index
].opt_text
+ 2,
3618 /* A warning with option. */
3620 return xstrdup (cl_options
[option_index
].opt_text
);
3622 /* A warning without option classified as an error. */
3623 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
3624 || diag_kind
== DK_WARNING
)
3625 && context
->warning_as_error_requested
)
3626 return xstrdup (cl_options
[OPT_Werror
].opt_text
);
3631 /* Get the page within the documentation for this option. */
3634 get_option_html_page (int option_index
)
3636 const cl_option
*cl_opt
= &cl_options
[option_index
];
3638 /* Analyzer options are on their own page. */
3639 if (strstr (cl_opt
->opt_text
, "analyzer-"))
3640 return "gcc/Static-Analyzer-Options.html";
3642 /* Handle -flto= option. */
3643 if (strstr (cl_opt
->opt_text
, "flto"))
3644 return "gcc/Optimize-Options.html";
3647 if ((cl_opt
->flags
& CL_Fortran
) != 0
3648 /* If it is option common to both C/C++ and Fortran, it is documented
3649 in gcc/ rather than gfortran/ docs. */
3650 && (cl_opt
->flags
& CL_C
) == 0
3652 && (cl_opt
->flags
& CL_CXX
) == 0
3655 return "gfortran/Error-and-Warning-Options.html";
3658 return "gcc/Warning-Options.html";
3661 /* Return malloced memory for a URL describing the option OPTION_INDEX
3662 which enabled a diagnostic (context CONTEXT). */
3665 get_option_url (diagnostic_context
*, int option_index
)
3668 return concat (/* DOCUMENTATION_ROOT_URL should be supplied via -D by
3669 the Makefile (see --with-documentation-root-url), and
3670 should have a trailing slash. */
3671 DOCUMENTATION_ROOT_URL
,
3673 /* get_option_html_page will return something like
3674 "gcc/Warning-Options.html". */
3675 get_option_html_page (option_index
),
3677 /* Expect an anchor of the form "index-Wfoo" e.g.
3678 <a name="index-Wformat"></a>, and thus an id within
3679 the URL of "#index-Wformat". */
3680 "#index", cl_options
[option_index
].opt_text
,
3686 /* Return a heap allocated producer with command line options. */
3689 gen_command_line_string (cl_decoded_option
*options
,
3690 unsigned int options_count
)
3692 auto_vec
<const char *> switches
;
3693 char *options_string
, *tail
;
3697 for (unsigned i
= 0; i
< options_count
; i
++)
3698 switch (options
[i
].opt_index
)
3703 case OPT_dumpbase_ext
:
3713 case OPT_SPECIAL_unknown
:
3714 case OPT_SPECIAL_ignore
:
3715 case OPT_SPECIAL_warn_removed
:
3716 case OPT_SPECIAL_program_name
:
3717 case OPT_SPECIAL_input_file
:
3718 case OPT_grecord_gcc_switches
:
3719 case OPT_frecord_gcc_switches
:
3720 case OPT__output_pch
:
3721 case OPT_fdiagnostics_show_location_
:
3722 case OPT_fdiagnostics_show_option
:
3723 case OPT_fdiagnostics_show_caret
:
3724 case OPT_fdiagnostics_show_labels
:
3725 case OPT_fdiagnostics_show_line_numbers
:
3726 case OPT_fdiagnostics_color_
:
3727 case OPT_fdiagnostics_format_
:
3728 case OPT_fverbose_asm
:
3732 case OPT_nostdinc__
:
3733 case OPT_fpreprocessed
:
3734 case OPT_fltrans_output_list_
:
3735 case OPT_fresolution_
:
3736 case OPT_fdebug_prefix_map_
:
3737 case OPT_fmacro_prefix_map_
:
3738 case OPT_ffile_prefix_map_
:
3739 case OPT_fprofile_prefix_map_
:
3740 case OPT_fcanon_prefix_map
:
3741 case OPT_fcompare_debug
:
3743 case OPT_fchecking_
:
3748 const char *lto_canonical
= "-flto";
3749 switches
.safe_push (lto_canonical
);
3750 len
+= strlen (lto_canonical
) + 1;
3754 if (cl_options
[options
[i
].opt_index
].flags
3755 & CL_NO_DWARF_RECORD
)
3757 gcc_checking_assert (options
[i
].canonical_option
[0][0] == '-');
3758 switch (options
[i
].canonical_option
[0][1])
3765 if (strncmp (options
[i
].canonical_option
[0] + 2,
3772 switches
.safe_push (options
[i
].orig_option_with_args_text
);
3773 len
+= strlen (options
[i
].orig_option_with_args_text
) + 1;
3777 options_string
= XNEWVEC (char, len
+ 1);
3778 tail
= options_string
;
3781 FOR_EACH_VEC_ELT (switches
, i
, p
)
3784 memcpy (tail
, p
, len
);
3786 if (i
!= switches
.length () - 1)
3794 return options_string
;
3797 /* Return a heap allocated producer string including command line options. */
3800 gen_producer_string (const char *language_string
, cl_decoded_option
*options
,
3801 unsigned int options_count
)
3803 char *cmdline
= gen_command_line_string (options
, options_count
);
3804 char *combined
= concat (language_string
, " ", version_string
, " ",
3812 namespace selftest
{
3814 /* Verify that get_option_html_page works as expected. */
3817 test_get_option_html_page ()
3819 ASSERT_STREQ (get_option_html_page (OPT_Wcpp
), "gcc/Warning-Options.html");
3820 ASSERT_STREQ (get_option_html_page (OPT_Wanalyzer_double_free
),
3821 "gcc/Static-Analyzer-Options.html");
3823 ASSERT_STREQ (get_option_html_page (OPT_Wline_truncation
),
3824 "gfortran/Error-and-Warning-Options.html");
3828 /* Verify EnumSet and EnumBitSet requirements. */
3833 for (unsigned i
= 0; i
< cl_options_count
; ++i
)
3834 if (cl_options
[i
].var_type
== CLVC_ENUM
3835 && cl_options
[i
].var_value
!= CLEV_NORMAL
)
3837 const struct cl_enum
*e
= &cl_enums
[cl_options
[i
].var_enum
];
3838 unsigned HOST_WIDE_INT used_sets
= 0;
3839 unsigned HOST_WIDE_INT mask
= 0;
3840 unsigned highest_set
= 0;
3841 for (unsigned j
= 0; e
->values
[j
].arg
; ++j
)
3843 unsigned set
= e
->values
[j
].flags
>> CL_ENUM_SET_SHIFT
;
3844 if (cl_options
[i
].var_value
== CLEV_BITSET
)
3846 /* For EnumBitSet Set shouldn't be used and Value should
3847 be a power of two. */
3848 ASSERT_TRUE (set
== 0);
3849 ASSERT_TRUE (pow2p_hwi (e
->values
[j
].value
));
3852 /* Test that enumerators referenced in EnumSet have all
3853 Set(n) on them within the valid range. */
3854 ASSERT_TRUE (set
>= 1 && set
<= HOST_BITS_PER_WIDE_INT
);
3855 highest_set
= MAX (set
, highest_set
);
3856 used_sets
|= HOST_WIDE_INT_1U
<< (set
- 1);
3858 if (cl_options
[i
].var_value
== CLEV_BITSET
)
3860 /* If there is just one set, no point to using EnumSet. */
3861 ASSERT_TRUE (highest_set
>= 2);
3862 /* Test that there are no gaps in between the sets. */
3863 if (highest_set
== HOST_BITS_PER_WIDE_INT
)
3864 ASSERT_TRUE (used_sets
== HOST_WIDE_INT_M1U
);
3866 ASSERT_TRUE (used_sets
== (HOST_WIDE_INT_1U
<< highest_set
) - 1);
3867 for (unsigned int j
= 1; j
<= highest_set
; ++j
)
3869 unsigned HOST_WIDE_INT this_mask
= 0;
3870 for (unsigned k
= 0; e
->values
[k
].arg
; ++k
)
3872 unsigned set
= e
->values
[j
].flags
>> CL_ENUM_SET_SHIFT
;
3874 this_mask
|= e
->values
[j
].value
;
3876 ASSERT_TRUE ((mask
& this_mask
) == 0);
3882 /* Run all of the selftests within this file. */
3887 test_get_option_html_page ();
3891 } // namespace selftest
3893 #endif /* #if CHECKING_P */