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;
1387 opts
->x_flag_var_tracking_assignments
= 0;
1390 /* One could use EnabledBy, but it would lead to a circular dependency. */
1391 if (!opts_set
->x_flag_var_tracking_uninit
)
1392 opts
->x_flag_var_tracking_uninit
= opts
->x_flag_var_tracking
;
1394 if (!opts_set
->x_flag_var_tracking_assignments
)
1395 opts
->x_flag_var_tracking_assignments
1396 = (opts
->x_flag_var_tracking
1397 && !(opts
->x_flag_selective_scheduling
1398 || opts
->x_flag_selective_scheduling2
));
1400 if (opts
->x_flag_var_tracking_assignments_toggle
)
1401 opts
->x_flag_var_tracking_assignments
1402 = !opts
->x_flag_var_tracking_assignments
;
1404 if (opts
->x_flag_var_tracking_assignments
&& !opts
->x_flag_var_tracking
)
1405 opts
->x_flag_var_tracking
= opts
->x_flag_var_tracking_assignments
= -1;
1407 if (opts
->x_flag_var_tracking_assignments
1408 && (opts
->x_flag_selective_scheduling
1409 || opts
->x_flag_selective_scheduling2
))
1411 "var-tracking-assignments changes selective scheduling");
1413 if (opts
->x_flag_syntax_only
)
1415 opts
->x_write_symbols
= NO_DEBUG
;
1416 opts
->x_profile_flag
= 0;
1419 if (opts
->x_warn_strict_flex_arrays
)
1420 if (opts
->x_flag_strict_flex_arrays
== 0)
1422 opts
->x_warn_strict_flex_arrays
= 0;
1423 warning_at (UNKNOWN_LOCATION
, 0,
1424 "%<-Wstrict-flex-arrays%> is ignored when"
1425 " %<-fstrict-flex-arrays%> is not present");
1428 diagnose_options (opts
, opts_set
, loc
);
1431 /* The function diagnoses incompatible combinations for provided options
1432 (OPTS and OPTS_SET) at a given LOCation. The function is called both
1433 when command line is parsed (after the target optimization hook) and
1434 when an optimize/target attribute (or pragma) is used. */
1436 void diagnose_options (gcc_options
*opts
, gcc_options
*opts_set
,
1439 /* The optimization to partition hot and cold basic blocks into separate
1440 sections of the .o and executable files does not work (currently)
1441 with exception handling. This is because there is no support for
1442 generating unwind info. If opts->x_flag_exceptions is turned on
1443 we need to turn off the partitioning optimization. */
1445 enum unwind_info_type ui_except
1446 = targetm_common
.except_unwind_info (opts
);
1448 if (opts
->x_flag_exceptions
1449 && opts
->x_flag_reorder_blocks_and_partition
1450 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1452 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1454 "%<-freorder-blocks-and-partition%> does not work "
1455 "with exceptions on this architecture");
1456 opts
->x_flag_reorder_blocks_and_partition
= 0;
1457 opts
->x_flag_reorder_blocks
= 1;
1460 /* If user requested unwind info, then turn off the partitioning
1463 if (opts
->x_flag_unwind_tables
1464 && !targetm_common
.unwind_tables_default
1465 && opts
->x_flag_reorder_blocks_and_partition
1466 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1468 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1470 "%<-freorder-blocks-and-partition%> does not support "
1471 "unwind info on this architecture");
1472 opts
->x_flag_reorder_blocks_and_partition
= 0;
1473 opts
->x_flag_reorder_blocks
= 1;
1476 /* If the target requested unwind info, then turn off the partitioning
1477 optimization with a different message. Likewise, if the target does not
1478 support named sections. */
1480 if (opts
->x_flag_reorder_blocks_and_partition
1481 && (!targetm_common
.have_named_sections
1482 || (opts
->x_flag_unwind_tables
1483 && targetm_common
.unwind_tables_default
1484 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
1486 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1488 "%<-freorder-blocks-and-partition%> does not work "
1489 "on this architecture");
1490 opts
->x_flag_reorder_blocks_and_partition
= 0;
1491 opts
->x_flag_reorder_blocks
= 1;
1497 #define LEFT_COLUMN 27
1499 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1500 followed by word-wrapped HELP in a second column. */
1502 wrap_help (const char *help
,
1504 unsigned int item_width
,
1505 unsigned int columns
)
1507 unsigned int col_width
= LEFT_COLUMN
;
1508 unsigned int remaining
, room
, len
;
1510 remaining
= strlen (help
);
1514 room
= columns
- 3 - MAX (col_width
, item_width
);
1523 for (i
= 0; help
[i
]; i
++)
1525 if (i
>= room
&& len
!= remaining
)
1529 else if ((help
[i
] == '-' || help
[i
] == '/')
1530 && help
[i
+ 1] != ' '
1531 && i
> 0 && ISALPHA (help
[i
- 1]))
1536 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1538 while (help
[len
] == ' ')
1546 /* Data structure used to print list of valid option values. */
1548 class option_help_tuple
1551 option_help_tuple (int code
, vec
<const char *> values
):
1552 m_code (code
), m_values (values
)
1555 /* Code of an option. */
1558 /* List of possible values. */
1559 vec
<const char *> m_values
;
1562 /* Print help for a specific front-end, etc. */
1564 print_filtered_help (unsigned int include_flags
,
1565 unsigned int exclude_flags
,
1566 unsigned int any_flags
,
1567 unsigned int columns
,
1568 struct gcc_options
*opts
,
1569 unsigned int lang_mask
)
1574 bool displayed
= false;
1577 if (!opts
->x_help_printed
)
1578 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1580 if (!opts
->x_help_enum_printed
)
1581 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1583 auto_vec
<option_help_tuple
> help_tuples
;
1585 for (i
= 0; i
< cl_options_count
; i
++)
1587 const struct cl_option
*option
= cl_options
+ i
;
1592 if (include_flags
== 0
1593 || ((option
->flags
& include_flags
) != include_flags
))
1595 if ((option
->flags
& any_flags
) == 0)
1599 /* Skip unwanted switches. */
1600 if ((option
->flags
& exclude_flags
) != 0)
1603 /* The driver currently prints its own help text. */
1604 if ((option
->flags
& CL_DRIVER
) != 0
1605 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1606 | CL_COMMON
| CL_TARGET
)) == 0)
1609 /* If an option contains a language specification,
1610 exclude it from common unless all languages are present. */
1611 if ((include_flags
& CL_COMMON
)
1612 && !(option
->flags
& CL_DRIVER
)
1613 && (option
->flags
& CL_LANG_ALL
)
1614 && (option
->flags
& CL_LANG_ALL
) != CL_LANG_ALL
)
1618 /* Skip switches that have already been printed. */
1619 if (opts
->x_help_printed
[i
])
1622 opts
->x_help_printed
[i
] = true;
1624 help
= option
->help
;
1627 if (exclude_flags
& CL_UNDOCUMENTED
)
1630 help
= undocumented_msg
;
1633 /* Get the translation. */
1636 if (option
->alias_target
< N_OPTS
1637 && cl_options
[option
->alias_target
].help
)
1639 const struct cl_option
*target
= cl_options
+ option
->alias_target
;
1640 if (option
->help
== NULL
)
1642 /* The option is undocumented but is an alias for an option that
1643 is documented. If the option has alias arguments, then its
1644 purpose is to provide certain arguments to the other option, so
1645 inform the reader of this. Otherwise, point the reader to the
1646 other option in preference to the former. */
1648 if (option
->alias_arg
)
1650 if (option
->neg_alias_arg
)
1651 snprintf (new_help
, sizeof new_help
,
1652 _("Same as %s%s (or, in negated form, %s%s)."),
1653 target
->opt_text
, option
->alias_arg
,
1654 target
->opt_text
, option
->neg_alias_arg
);
1656 snprintf (new_help
, sizeof new_help
,
1658 target
->opt_text
, option
->alias_arg
);
1661 snprintf (new_help
, sizeof new_help
,
1667 /* For documented options with aliases, mention the aliased
1668 option's name for reference. */
1669 snprintf (new_help
, sizeof new_help
,
1670 _("%s Same as %s."),
1671 help
, cl_options
[option
->alias_target
].opt_text
);
1677 if (option
->warn_message
)
1679 /* Mention that the use of the option will trigger a warning. */
1680 if (help
== new_help
)
1681 snprintf (new_help
+ strlen (new_help
),
1682 sizeof new_help
- strlen (new_help
),
1683 " %s", _(use_diagnosed_msg
));
1685 snprintf (new_help
, sizeof new_help
,
1686 "%s %s", help
, _(use_diagnosed_msg
));
1691 /* Find the gap between the name of the
1692 option and its descriptive text. */
1693 tab
= strchr (help
, '\t');
1702 opt
= option
->opt_text
;
1706 /* With the -Q option enabled we change the descriptive text associated
1707 with an option to be an indication of its current setting. */
1708 if (!opts
->x_quiet_flag
)
1710 void *flag_var
= option_flag_var (i
, opts
);
1712 if (len
< (LEFT_COLUMN
+ 2))
1713 strcpy (new_help
, "\t\t");
1715 strcpy (new_help
, "\t");
1717 /* Set to print whether the option is enabled or disabled,
1718 or, if it's an alias for another option, the name of
1719 the aliased option. */
1720 bool print_state
= false;
1722 if (flag_var
!= NULL
1723 && option
->var_type
!= CLVC_DEFER
)
1725 /* If OPTION is only available for a specific subset
1726 of languages other than this one, mention them. */
1727 bool avail_for_lang
= true;
1728 if (unsigned langset
= option
->flags
& CL_LANG_ALL
)
1730 if (!(langset
& lang_mask
))
1732 avail_for_lang
= false;
1733 strcat (new_help
, _("[available in "));
1734 for (unsigned i
= 0, n
= 0; (1U << i
) < CL_LANG_ALL
; ++i
)
1735 if (langset
& (1U << i
))
1738 strcat (new_help
, ", ");
1739 strcat (new_help
, lang_names
[i
]);
1741 strcat (new_help
, "]");
1744 if (!avail_for_lang
)
1745 ; /* Print nothing else if the option is not available
1746 in the current language. */
1747 else if (option
->flags
& CL_JOINED
)
1749 if (option
->var_type
== CLVC_STRING
)
1751 if (* (const char **) flag_var
!= NULL
)
1752 snprintf (new_help
+ strlen (new_help
),
1753 sizeof (new_help
) - strlen (new_help
),
1754 "%s", * (const char **) flag_var
);
1756 else if (option
->var_type
== CLVC_ENUM
)
1758 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1760 const char *arg
= NULL
;
1762 value
= e
->get (flag_var
);
1763 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1765 arg
= _("[default]");
1766 snprintf (new_help
+ strlen (new_help
),
1767 sizeof (new_help
) - strlen (new_help
),
1772 if (option
->cl_host_wide_int
)
1773 sprintf (new_help
+ strlen (new_help
),
1774 _("%llu bytes"), (unsigned long long)
1775 *(unsigned HOST_WIDE_INT
*) flag_var
);
1777 sprintf (new_help
+ strlen (new_help
),
1778 "%i", * (int *) flag_var
);
1785 /* When there is no argument, print the option state only
1786 if the option takes no argument. */
1787 print_state
= !(option
->flags
& CL_JOINED
);
1791 if (option
->alias_target
< N_OPTS
1792 && option
->alias_target
!= OPT_SPECIAL_warn_removed
1793 && option
->alias_target
!= OPT_SPECIAL_ignore
1794 && option
->alias_target
!= OPT_SPECIAL_input_file
1795 && option
->alias_target
!= OPT_SPECIAL_program_name
1796 && option
->alias_target
!= OPT_SPECIAL_unknown
)
1798 const struct cl_option
*target
1799 = &cl_options
[option
->alias_target
];
1800 sprintf (new_help
+ strlen (new_help
), "%s%s",
1802 option
->alias_arg
? option
->alias_arg
: "");
1804 else if (option
->alias_target
== OPT_SPECIAL_ignore
)
1805 strcat (new_help
, ("[ignored]"));
1808 /* Print the state for an on/off option. */
1809 int ena
= option_enabled (i
, lang_mask
, opts
);
1811 strcat (new_help
, _("[enabled]"));
1813 strcat (new_help
, _("[disabled]"));
1820 if (option
->range_max
!= -1 && tab
== NULL
)
1823 snprintf (b
, sizeof (b
), "<%d,%d>", option
->range_min
,
1825 opt
= concat (opt
, b
, NULL
);
1829 wrap_help (help
, opt
, len
, columns
);
1832 if (option
->var_type
== CLVC_ENUM
1833 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1834 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1837 vec
<const char *> option_values
1838 = targetm_common
.get_valid_option_values (i
, NULL
);
1839 if (!option_values
.is_empty ())
1840 help_tuples
.safe_push (option_help_tuple (i
, option_values
));
1846 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1849 printf (_(" No options with the desired characteristics were found\n"));
1854 /* PR 31349: Tell the user how to see all of the
1855 options supported by a specific front end. */
1856 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1857 if ((1U << i
) & langs
)
1858 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1859 lang_names
[i
], lang_names
[i
]);
1863 else if (! displayed
)
1864 printf (_(" All options with the desired characteristics have already been displayed\n"));
1868 /* Print details of enumerated option arguments, if those
1869 enumerations have help text headings provided. If no help text
1870 is provided, presume that the possible values are listed in the
1871 help text for the relevant options. */
1872 for (i
= 0; i
< cl_enums_count
; i
++)
1874 unsigned int j
, pos
;
1876 if (opts
->x_help_enum_printed
[i
] != 1)
1878 if (cl_enums
[i
].help
== NULL
)
1880 printf (" %s\n ", _(cl_enums
[i
].help
));
1882 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1884 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1886 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1888 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1898 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1903 opts
->x_help_enum_printed
[i
] = 2;
1906 for (unsigned i
= 0; i
< help_tuples
.length (); i
++)
1908 const struct cl_option
*option
= cl_options
+ help_tuples
[i
].m_code
;
1909 printf (_(" Known valid arguments for %s option:\n "),
1911 for (unsigned j
= 0; j
< help_tuples
[i
].m_values
.length (); j
++)
1912 printf (" %s", help_tuples
[i
].m_values
[j
]);
1917 /* Display help for a specified type of option.
1918 The options must have ALL of the INCLUDE_FLAGS set
1919 ANY of the flags in the ANY_FLAGS set
1920 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1921 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1923 print_specific_help (unsigned int include_flags
,
1924 unsigned int exclude_flags
,
1925 unsigned int any_flags
,
1926 struct gcc_options
*opts
,
1927 unsigned int lang_mask
)
1929 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1930 const char * description
= NULL
;
1931 const char * descrip_extra
= "";
1935 /* Sanity check: Make sure that we do not have more
1936 languages than we have bits available to enumerate them. */
1937 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1939 /* If we have not done so already, obtain
1940 the desired maximum width of the output. */
1941 if (opts
->x_help_columns
== 0)
1943 opts
->x_help_columns
= get_terminal_width ();
1944 if (opts
->x_help_columns
== INT_MAX
)
1945 /* Use a reasonable default. */
1946 opts
->x_help_columns
= 80;
1949 /* Decide upon the title for the options that we are going to display. */
1950 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1952 switch (flag
& include_flags
)
1959 description
= _("The following options are target specific");
1962 description
= _("The following options control compiler warning messages");
1964 case CL_OPTIMIZATION
:
1965 description
= _("The following options control optimizations");
1968 description
= _("The following options are language-independent");
1971 description
= _("The following options control parameters");
1974 if (i
>= cl_lang_count
)
1976 if (exclude_flags
& all_langs_mask
)
1977 description
= _("The following options are specific to just the language ");
1979 description
= _("The following options are supported by the language ");
1980 descrip_extra
= lang_names
[i
];
1985 if (description
== NULL
)
1989 if (include_flags
& CL_UNDOCUMENTED
)
1990 description
= _("The following options are not documented");
1991 else if (include_flags
& CL_SEPARATE
)
1992 description
= _("The following options take separate arguments");
1993 else if (include_flags
& CL_JOINED
)
1994 description
= _("The following options take joined arguments");
1997 internal_error ("unrecognized %<include_flags 0x%x%> passed "
1998 "to %<print_specific_help%>",
2005 if (any_flags
& all_langs_mask
)
2006 description
= _("The following options are language-related");
2008 description
= _("The following options are language-independent");
2012 printf ("%s%s:\n", description
, descrip_extra
);
2013 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
2014 opts
->x_help_columns
, opts
, lang_mask
);
2017 /* Enable FDO-related flags. */
2020 enable_fdo_optimizations (struct gcc_options
*opts
,
2021 struct gcc_options
*opts_set
,
2024 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_branch_probabilities
, value
);
2025 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
2026 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_loops
, value
);
2027 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_peel_loops
, value
);
2028 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tracer
, value
);
2029 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_value_profile_transformations
,
2031 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
2032 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp
, value
);
2035 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp_clone
, 1);
2036 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, 1);
2038 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_predictive_commoning
, value
);
2039 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_split_loops
, value
);
2040 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unswitch_loops
, value
);
2041 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_gcse_after_reload
, value
);
2042 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_vectorize
, value
);
2043 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_slp_vectorize
, value
);
2044 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_version_loops_for_strides
, value
);
2045 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_vect_cost_model
,
2046 VECT_COST_MODEL_DYNAMIC
);
2047 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribute_patterns
,
2049 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_loop_interchange
, value
);
2050 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_jam
, value
);
2051 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribution
, value
);
2054 /* -f{,no-}sanitize{,-recover}= suboptions. */
2055 const struct sanitizer_opts_s sanitizer_opts
[] =
2057 #define SANITIZER_OPT(name, flags, recover, trap) \
2058 { #name, flags, sizeof #name - 1, recover, trap }
2059 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true,
2061 SANITIZER_OPT (hwaddress
, (SANITIZE_HWADDRESS
| SANITIZE_USER_HWADDRESS
),
2063 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
2065 SANITIZER_OPT (kernel
-hwaddress
,
2066 (SANITIZE_HWADDRESS
| SANITIZE_KERNEL_HWADDRESS
),
2068 SANITIZER_OPT (pointer
-compare
, SANITIZE_POINTER_COMPARE
, true, false),
2069 SANITIZER_OPT (pointer
-subtract
, SANITIZE_POINTER_SUBTRACT
, true, false),
2070 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false, false),
2071 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false, false),
2072 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true, true),
2073 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true, true),
2074 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true, true),
2075 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true, true),
2076 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true, true),
2077 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false, true),
2078 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true, true),
2079 SANITIZER_OPT (return, SANITIZE_RETURN
, false, true),
2080 SANITIZER_OPT (null
, SANITIZE_NULL
, true, true),
2081 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true, true),
2082 SANITIZER_OPT (bool, SANITIZE_BOOL
, true, true),
2083 SANITIZER_OPT (enum, SANITIZE_ENUM
, true, true),
2084 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true, true),
2085 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true, true),
2086 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true, true),
2087 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true,
2089 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true, true),
2090 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true, true),
2091 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
2093 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true, true),
2094 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true, false),
2095 SANITIZER_OPT (pointer
-overflow
, SANITIZE_POINTER_OVERFLOW
, true, true),
2096 SANITIZER_OPT (builtin
, SANITIZE_BUILTIN
, true, true),
2097 SANITIZER_OPT (shadow
-call
-stack
, SANITIZE_SHADOW_CALL_STACK
, false, false),
2098 SANITIZER_OPT (all
, ~0U, true, true),
2099 #undef SANITIZER_OPT
2100 { NULL
, 0U, 0UL, false, false }
2103 /* -fzero-call-used-regs= suboptions. */
2104 const struct zero_call_used_regs_opts_s zero_call_used_regs_opts
[] =
2106 #define ZERO_CALL_USED_REGS_OPT(name, flags) \
2108 ZERO_CALL_USED_REGS_OPT (skip
, zero_regs_flags::SKIP
),
2109 ZERO_CALL_USED_REGS_OPT (used
-gpr
-arg
, zero_regs_flags::USED_GPR_ARG
),
2110 ZERO_CALL_USED_REGS_OPT (used
-gpr
, zero_regs_flags::USED_GPR
),
2111 ZERO_CALL_USED_REGS_OPT (used
-arg
, zero_regs_flags::USED_ARG
),
2112 ZERO_CALL_USED_REGS_OPT (used
, zero_regs_flags::USED
),
2113 ZERO_CALL_USED_REGS_OPT (all
-gpr
-arg
, zero_regs_flags::ALL_GPR_ARG
),
2114 ZERO_CALL_USED_REGS_OPT (all
-gpr
, zero_regs_flags::ALL_GPR
),
2115 ZERO_CALL_USED_REGS_OPT (all
-arg
, zero_regs_flags::ALL_ARG
),
2116 ZERO_CALL_USED_REGS_OPT (all
, zero_regs_flags::ALL
),
2117 #undef ZERO_CALL_USED_REGS_OPT
2121 /* A struct for describing a run of chars within a string. */
2123 class string_fragment
2126 string_fragment (const char *start
, size_t len
)
2127 : m_start (start
), m_len (len
) {}
2129 const char *m_start
;
2133 /* Specialization of edit_distance_traits for string_fragment,
2134 for use by get_closest_sanitizer_option. */
2137 struct edit_distance_traits
<const string_fragment
&>
2139 static size_t get_length (const string_fragment
&fragment
)
2141 return fragment
.m_len
;
2144 static const char *get_string (const string_fragment
&fragment
)
2146 return fragment
.m_start
;
2150 /* Given ARG, an unrecognized sanitizer option, return the best
2151 matching sanitizer option, or NULL if there isn't one.
2152 OPTS is array of candidate sanitizer options.
2153 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or OPT_fsanitize_trap_.
2154 VALUE is non-zero for the regular form of the option, zero
2155 for the "no-" form (e.g. "-fno-sanitize-recover="). */
2158 get_closest_sanitizer_option (const string_fragment
&arg
,
2159 const struct sanitizer_opts_s
*opts
,
2160 enum opt_code code
, int value
)
2162 best_match
<const string_fragment
&, const char*> bm (arg
);
2163 for (int i
= 0; opts
[i
].name
!= NULL
; ++i
)
2165 /* -fsanitize=all is not valid, so don't offer it. */
2166 if (code
== OPT_fsanitize_
2167 && opts
[i
].flag
== ~0U
2171 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
2172 don't offer the non-recoverable options. */
2173 if (code
== OPT_fsanitize_recover_
2174 && !opts
[i
].can_recover
2178 /* For -fsanitize-trap= (and not -fno-sanitize-trap=),
2179 don't offer the non-trapping options. */
2180 if (code
== OPT_fsanitize_trap_
2181 && !opts
[i
].can_trap
2185 bm
.consider (opts
[i
].name
);
2187 return bm
.get_best_meaningful_candidate ();
2190 /* Parse comma separated sanitizer suboptions from P for option SCODE,
2191 adjust previous FLAGS and return new ones. If COMPLAIN is false,
2192 don't issue diagnostics. */
2195 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
2196 unsigned int flags
, int value
, bool complain
)
2198 enum opt_code code
= (enum opt_code
) scode
;
2204 const char *comma
= strchr (p
, ',');
2216 /* Check to see if the string matches an option class name. */
2217 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
2218 if (len
== sanitizer_opts
[i
].len
2219 && memcmp (p
, sanitizer_opts
[i
].name
, len
) == 0)
2221 /* Handle both -fsanitize and -fno-sanitize cases. */
2222 if (value
&& sanitizer_opts
[i
].flag
== ~0U)
2224 if (code
== OPT_fsanitize_
)
2227 error_at (loc
, "%<-fsanitize=all%> option is not valid");
2229 else if (code
== OPT_fsanitize_recover_
)
2230 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
2231 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
2232 | SANITIZE_SHADOW_CALL_STACK
);
2233 else /* if (code == OPT_fsanitize_trap_) */
2234 flags
|= (SANITIZE_UNDEFINED
2235 | SANITIZE_UNDEFINED_NONDEFAULT
);
2239 /* Do not enable -fsanitize-recover=unreachable and
2240 -fsanitize-recover=return if -fsanitize-recover=undefined
2242 if (code
== OPT_fsanitize_recover_
2243 && sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
2244 flags
|= (SANITIZE_UNDEFINED
2245 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
2246 else if (code
== OPT_fsanitize_trap_
2247 && sanitizer_opts
[i
].flag
== SANITIZE_VPTR
)
2248 error_at (loc
, "%<-fsanitize-trap=%s%> is not supported",
2249 sanitizer_opts
[i
].name
);
2251 flags
|= sanitizer_opts
[i
].flag
;
2255 flags
&= ~sanitizer_opts
[i
].flag
;
2256 /* Don't always clear SANITIZE_ADDRESS if it was previously
2257 set: -fsanitize=address -fno-sanitize=kernel-address should
2258 leave SANITIZE_ADDRESS set. */
2259 if (flags
& (SANITIZE_KERNEL_ADDRESS
| SANITIZE_USER_ADDRESS
))
2260 flags
|= SANITIZE_ADDRESS
;
2266 if (! found
&& complain
)
2269 = get_closest_sanitizer_option (string_fragment (p
, len
),
2270 sanitizer_opts
, code
, value
);
2273 if (code
== OPT_fsanitize_recover_
)
2274 suffix
= "-recover";
2275 else if (code
== OPT_fsanitize_trap_
)
2282 "unrecognized argument to %<-f%ssanitize%s=%> "
2283 "option: %q.*s; did you mean %qs?",
2285 suffix
, (int) len
, p
, hint
);
2288 "unrecognized argument to %<-f%ssanitize%s=%> option: "
2289 "%q.*s", value
? "" : "no-",
2290 suffix
, (int) len
, p
);
2300 /* Parse string values of no_sanitize attribute passed in VALUE.
2301 Values are separated with comma. */
2304 parse_no_sanitize_attribute (char *value
)
2306 unsigned int flags
= 0;
2308 char *q
= strtok (value
, ",");
2312 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
2313 if (strcmp (sanitizer_opts
[i
].name
, q
) == 0)
2315 flags
|= sanitizer_opts
[i
].flag
;
2316 if (sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
2317 flags
|= SANITIZE_UNDEFINED_NONDEFAULT
;
2321 if (sanitizer_opts
[i
].name
== NULL
)
2322 warning (OPT_Wattributes
,
2323 "%qs attribute directive ignored", q
);
2325 q
= strtok (NULL
, ",");
2331 /* Parse -fzero-call-used-regs suboptions from ARG, return the FLAGS. */
2334 parse_zero_call_used_regs_options (const char *arg
)
2336 unsigned int flags
= 0;
2338 /* Check to see if the string matches a sub-option name. */
2339 for (unsigned int i
= 0; zero_call_used_regs_opts
[i
].name
!= NULL
; ++i
)
2340 if (strcmp (arg
, zero_call_used_regs_opts
[i
].name
) == 0)
2342 flags
= zero_call_used_regs_opts
[i
].flag
;
2347 error ("unrecognized argument to %<-fzero-call-used-regs=%>: %qs", arg
);
2352 /* Parse -falign-NAME format for a FLAG value. Return individual
2353 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
2354 set, print error message at LOC location. */
2357 parse_and_check_align_values (const char *flag
,
2359 auto_vec
<unsigned> &result_values
,
2363 char *str
= xstrdup (flag
);
2364 for (char *p
= strtok (str
, ":"); p
; p
= strtok (NULL
, ":"))
2367 int v
= strtol (p
, &end
, 10);
2368 if (*end
!= '\0' || v
< 0)
2371 error_at (loc
, "invalid arguments for %<-falign-%s%> option: %qs",
2377 result_values
.safe_push ((unsigned)v
);
2382 /* Check that we have a correct number of values. */
2383 if (result_values
.is_empty () || result_values
.length () > 4)
2386 error_at (loc
, "invalid number of arguments for %<-falign-%s%> "
2387 "option: %qs", name
, flag
);
2391 for (unsigned i
= 0; i
< result_values
.length (); i
++)
2392 if (result_values
[i
] > MAX_CODE_ALIGN_VALUE
)
2395 error_at (loc
, "%<-falign-%s%> is not between 0 and %d",
2396 name
, MAX_CODE_ALIGN_VALUE
);
2403 /* Check that alignment value FLAG for -falign-NAME is valid at a given
2404 location LOC. OPT_STR points to the stored -falign-NAME=argument and
2405 OPT_FLAG points to the associated -falign-NAME on/off flag. */
2408 check_alignment_argument (location_t loc
, const char *flag
, const char *name
,
2409 int *opt_flag
, const char **opt_str
)
2411 auto_vec
<unsigned> align_result
;
2412 parse_and_check_align_values (flag
, name
, align_result
, true, loc
);
2414 if (align_result
.length() >= 1 && align_result
[0] == 0)
2421 /* Parse argument of -fpatchable-function-entry option ARG and store
2422 corresponding values to PATCH_AREA_SIZE and PATCH_AREA_START.
2423 If REPORT_ERROR is set to true, generate error for a problematic
2424 option arguments. */
2427 parse_and_check_patch_area (const char *arg
, bool report_error
,
2428 HOST_WIDE_INT
*patch_area_size
,
2429 HOST_WIDE_INT
*patch_area_start
)
2431 *patch_area_size
= 0;
2432 *patch_area_start
= 0;
2437 char *patch_area_arg
= xstrdup (arg
);
2438 char *comma
= strchr (patch_area_arg
, ',');
2442 *patch_area_size
= integral_argument (patch_area_arg
);
2443 *patch_area_start
= integral_argument (comma
+ 1);
2446 *patch_area_size
= integral_argument (patch_area_arg
);
2448 if (*patch_area_size
< 0
2449 || *patch_area_size
> USHRT_MAX
2450 || *patch_area_start
< 0
2451 || *patch_area_start
> USHRT_MAX
2452 || *patch_area_size
< *patch_area_start
)
2454 error ("invalid arguments for %<-fpatchable-function-entry%>");
2456 free (patch_area_arg
);
2459 /* Print help when OPT__help_ is set. */
2462 print_help (struct gcc_options
*opts
, unsigned int lang_mask
,
2463 const char *help_option_argument
)
2465 const char *a
= help_option_argument
;
2466 unsigned int include_flags
= 0;
2467 /* Note - by default we include undocumented options when listing
2468 specific classes. If you only want to see documented options
2469 then add ",^undocumented" to the --help= option. E.g.:
2471 --help=target,^undocumented */
2472 unsigned int exclude_flags
= 0;
2474 if (lang_mask
== CL_DRIVER
)
2477 /* Walk along the argument string, parsing each word in turn.
2479 arg = [^]{word}[,{arg}]
2480 word = {optimizers|target|warnings|undocumented|
2481 params|common|<language>} */
2491 { "optimizers", CL_OPTIMIZATION
},
2492 { "target", CL_TARGET
},
2493 { "warnings", CL_WARNING
},
2494 { "undocumented", CL_UNDOCUMENTED
},
2495 { "params", CL_PARAMS
},
2496 { "joined", CL_JOINED
},
2497 { "separate", CL_SEPARATE
},
2498 { "common", CL_COMMON
},
2501 unsigned int *pflags
;
2503 unsigned int lang_flag
, specific_flag
;
2512 error ("missing argument to %qs", "--help=^");
2515 pflags
= &exclude_flags
;
2518 pflags
= &include_flags
;
2520 comma
= strchr (a
, ',');
2531 /* Check to see if the string matches an option class name. */
2532 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
2533 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
2535 specific_flag
= specifics
[i
].flag
;
2539 /* Check to see if the string matches a language name.
2540 Note - we rely upon the alpha-sorted nature of the entries in
2541 the lang_names array, specifically that shorter names appear
2542 before their longer variants. (i.e. C before C++). That way
2543 when we are attempting to match --help=c for example we will
2544 match with C first and not C++. */
2545 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
2546 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
2548 lang_flag
= 1U << i
;
2552 if (specific_flag
!= 0)
2555 *pflags
|= specific_flag
;
2558 /* The option's argument matches both the start of a
2559 language name and the start of an option class name.
2560 We have a special case for when the user has
2561 specified "--help=c", but otherwise we have to issue
2563 if (strncasecmp (a
, "c", len
) == 0)
2564 *pflags
|= lang_flag
;
2567 "%<--help%> argument %q.*s is ambiguous, "
2568 "please be more specific",
2572 else if (lang_flag
!= 0)
2573 *pflags
|= lang_flag
;
2576 "unrecognized argument to %<--help=%> option: %q.*s",
2584 /* We started using PerFunction/Optimization for parameters and
2585 a warning. We should exclude these from optimization options. */
2586 if (include_flags
& CL_OPTIMIZATION
)
2587 exclude_flags
|= CL_WARNING
;
2588 if (!(include_flags
& CL_PARAMS
))
2589 exclude_flags
|= CL_PARAMS
;
2592 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
2596 /* Handle target- and language-independent options. Return zero to
2597 generate an "unknown option" message. Only options that need
2598 extra handling need to be listed here; if you simply want
2599 DECODED->value assigned to a variable, it happens automatically. */
2602 common_handle_option (struct gcc_options
*opts
,
2603 struct gcc_options
*opts_set
,
2604 const struct cl_decoded_option
*decoded
,
2605 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
2607 const struct cl_option_handlers
*handlers
,
2608 diagnostic_context
*dc
,
2609 void (*target_option_override_hook
) (void))
2611 size_t scode
= decoded
->opt_index
;
2612 const char *arg
= decoded
->arg
;
2613 HOST_WIDE_INT value
= decoded
->value
;
2614 enum opt_code code
= (enum opt_code
) scode
;
2616 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
2622 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
2623 unsigned int undoc_mask
;
2626 if (lang_mask
== CL_DRIVER
)
2629 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
2632 target_option_override_hook ();
2633 /* First display any single language specific options. */
2634 for (i
= 0; i
< cl_lang_count
; i
++)
2636 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
2638 /* Next display any multi language specific options. */
2639 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
2640 /* Then display any remaining, non-language options. */
2641 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
2643 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
2644 opts
->x_exit_after_options
= true;
2648 case OPT__target_help
:
2649 if (lang_mask
== CL_DRIVER
)
2652 target_option_override_hook ();
2653 print_specific_help (CL_TARGET
, 0, 0, opts
, lang_mask
);
2654 opts
->x_exit_after_options
= true;
2659 help_option_arguments
.safe_push (arg
);
2660 opts
->x_exit_after_options
= true;
2665 if (lang_mask
== CL_DRIVER
)
2668 opts
->x_exit_after_options
= true;
2671 case OPT__completion_
:
2674 case OPT_fsanitize_
:
2675 opts_set
->x_flag_sanitize
= true;
2676 opts
->x_flag_sanitize
2677 = parse_sanitizer_options (arg
, loc
, code
,
2678 opts
->x_flag_sanitize
, value
, true);
2680 /* Kernel ASan implies normal ASan but does not yet support
2682 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
2684 SET_OPTION_IF_UNSET (opts
, opts_set
,
2685 param_asan_instrumentation_with_call_threshold
,
2687 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_globals
, 0);
2688 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_stack
, 0);
2689 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_protect_allocas
, 0);
2690 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_use_after_return
, 0);
2692 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_HWADDRESS
)
2694 SET_OPTION_IF_UNSET (opts
, opts_set
,
2695 param_hwasan_instrument_stack
, 0);
2696 SET_OPTION_IF_UNSET (opts
, opts_set
,
2697 param_hwasan_random_frame_tag
, 0);
2698 SET_OPTION_IF_UNSET (opts
, opts_set
,
2699 param_hwasan_instrument_allocas
, 0);
2703 case OPT_fsanitize_recover_
:
2704 opts
->x_flag_sanitize_recover
2705 = parse_sanitizer_options (arg
, loc
, code
,
2706 opts
->x_flag_sanitize_recover
, value
, true);
2709 case OPT_fsanitize_trap_
:
2710 opts
->x_flag_sanitize_trap
2711 = parse_sanitizer_options (arg
, loc
, code
,
2712 opts
->x_flag_sanitize_trap
, value
, true);
2715 case OPT_fasan_shadow_offset_
:
2719 case OPT_fsanitize_address_use_after_scope
:
2720 opts
->x_flag_sanitize_address_use_after_scope
= value
;
2723 case OPT_fsanitize_recover
:
2725 opts
->x_flag_sanitize_recover
2726 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)
2727 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2729 opts
->x_flag_sanitize_recover
2730 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2733 case OPT_fsanitize_trap
:
2735 opts
->x_flag_sanitize_trap
2736 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2738 opts
->x_flag_sanitize_trap
2739 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2747 /* Currently handled in a prescan. */
2750 case OPT_Wattributes_
:
2751 if (lang_mask
== CL_DRIVER
)
2756 error_at (loc
, "arguments ignored for %<-Wattributes=%>; use "
2757 "%<-Wno-attributes=%> instead");
2760 else if (arg
[strlen (arg
) - 1] == ',')
2762 error_at (loc
, "trailing %<,%> in arguments for "
2763 "%<-Wno-attributes=%>");
2767 add_comma_separated_to_vector (&opts
->x_flag_ignored_attributes
, arg
);
2771 dc
->warning_as_error_requested
= value
;
2775 if (lang_mask
== CL_DRIVER
)
2778 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
2779 opts
, opts_set
, loc
, dc
);
2782 case OPT_Wfatal_errors
:
2783 dc
->fatal_errors
= value
;
2786 case OPT_Wstack_usage_
:
2787 opts
->x_flag_stack_usage_info
= value
!= -1;
2790 case OPT_Wstrict_aliasing
:
2791 set_Wstrict_aliasing (opts
, value
);
2794 case OPT_Wstrict_overflow
:
2795 opts
->x_warn_strict_overflow
= (value
2796 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2800 case OPT_Wsystem_headers
:
2801 dc
->dc_warn_system_headers
= value
;
2805 opts
->x_flag_gen_aux_info
= 1;
2809 decode_d_option (arg
, opts
, loc
, dc
);
2812 case OPT_fcall_used_
:
2813 case OPT_fcall_saved_
:
2821 case OPT_fdebug_prefix_map_
:
2822 case OPT_ffile_prefix_map_
:
2823 case OPT_fprofile_prefix_map_
:
2827 case OPT_fcanon_prefix_map
:
2828 flag_canon_prefix_map
= value
;
2831 case OPT_fcallgraph_info
:
2832 opts
->x_flag_callgraph_info
= CALLGRAPH_INFO_NAKED
;
2835 case OPT_fcallgraph_info_
:
2838 my_arg
= xstrdup (arg
);
2839 p
= strtok (my_arg
, ",");
2842 if (strcmp (p
, "su") == 0)
2844 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_STACK_USAGE
;
2845 opts
->x_flag_stack_usage_info
= true;
2847 else if (strcmp (p
, "da") == 0)
2848 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_DYNAMIC_ALLOC
;
2851 p
= strtok (NULL
, ",");
2857 case OPT_fdiagnostics_show_location_
:
2858 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2861 case OPT_fdiagnostics_show_caret
:
2862 dc
->show_caret
= value
;
2865 case OPT_fdiagnostics_show_labels
:
2866 dc
->show_labels_p
= value
;
2869 case OPT_fdiagnostics_show_line_numbers
:
2870 dc
->show_line_numbers_p
= value
;
2873 case OPT_fdiagnostics_color_
:
2874 diagnostic_color_init (dc
, value
);
2877 case OPT_fdiagnostics_urls_
:
2878 diagnostic_urls_init (dc
, value
);
2881 case OPT_fdiagnostics_format_
:
2883 const char *basename
= (opts
->x_dump_base_name
? opts
->x_dump_base_name
2884 : opts
->x_main_input_basename
);
2885 diagnostic_output_format_init (dc
, basename
,
2886 (enum diagnostics_output_format
)value
);
2890 case OPT_fdiagnostics_parseable_fixits
:
2891 dc
->extra_output_kind
= (value
2892 ? EXTRA_DIAGNOSTIC_OUTPUT_fixits_v1
2893 : EXTRA_DIAGNOSTIC_OUTPUT_none
);
2896 case OPT_fdiagnostics_column_unit_
:
2897 dc
->column_unit
= (enum diagnostics_column_unit
)value
;
2900 case OPT_fdiagnostics_column_origin_
:
2901 dc
->column_origin
= value
;
2904 case OPT_fdiagnostics_escape_format_
:
2905 dc
->escape_format
= (enum diagnostics_escape_format
)value
;
2908 case OPT_fdiagnostics_show_cwe
:
2909 dc
->show_cwe
= value
;
2912 case OPT_fdiagnostics_show_rules
:
2913 dc
->show_rules
= value
;
2916 case OPT_fdiagnostics_path_format_
:
2917 dc
->path_format
= (enum diagnostic_path_format
)value
;
2920 case OPT_fdiagnostics_show_path_depths
:
2921 dc
->show_path_depths
= value
;
2924 case OPT_fdiagnostics_show_option
:
2925 dc
->show_option_requested
= value
;
2928 case OPT_fdiagnostics_minimum_margin_width_
:
2929 dc
->min_margin_width
= value
;
2936 case OPT_ffast_math
:
2937 set_fast_math_flags (opts
, value
);
2940 case OPT_funsafe_math_optimizations
:
2941 set_unsafe_math_optimizations_flags (opts
, value
);
2948 case OPT_finline_limit_
:
2949 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_single
,
2951 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_auto
,
2955 case OPT_finstrument_functions_exclude_function_list_
:
2956 add_comma_separated_to_vector
2957 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2960 case OPT_finstrument_functions_exclude_file_list_
:
2961 add_comma_separated_to_vector
2962 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2965 case OPT_fmessage_length_
:
2966 pp_set_line_maximum_length (dc
->printer
, value
);
2967 diagnostic_set_caret_max_width (dc
, value
);
2971 case OPT_fopt_info_
:
2975 case OPT_foffload_options_
:
2979 case OPT_foffload_abi_
:
2980 #ifdef ACCEL_COMPILER
2981 /* Handled in the 'mkoffload's. */
2983 error_at (loc
, "%<-foffload-abi%> option can be specified only for "
2984 "offload compiler");
2988 case OPT_fpack_struct_
:
2989 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2991 "structure alignment must be a small power of two, not %wu",
2994 opts
->x_initial_max_fld_align
= value
;
2998 case OPT_fplugin_arg_
:
3002 case OPT_fprofile_use_
:
3003 opts
->x_profile_data_prefix
= xstrdup (arg
);
3004 opts
->x_flag_profile_use
= true;
3006 /* No break here - do -fprofile-use processing. */
3008 case OPT_fprofile_use
:
3009 enable_fdo_optimizations (opts
, opts_set
, value
);
3010 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_reorder_functions
,
3012 /* Indirect call profiling should do all useful transformations
3013 speculative devirtualization does. */
3014 if (opts
->x_flag_value_profile_transformations
)
3015 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_devirtualize_speculatively
,
3019 case OPT_fauto_profile_
:
3020 opts
->x_auto_profile_file
= xstrdup (arg
);
3021 opts
->x_flag_auto_profile
= true;
3023 /* No break here - do -fauto-profile processing. */
3025 case OPT_fauto_profile
:
3026 enable_fdo_optimizations (opts
, opts_set
, value
);
3027 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_correction
, value
);
3030 case OPT_fprofile_generate_
:
3031 opts
->x_profile_data_prefix
= xstrdup (arg
);
3033 /* No break here - do -fprofile-generate processing. */
3035 case OPT_fprofile_generate
:
3036 SET_OPTION_IF_UNSET (opts
, opts_set
, profile_arc_flag
, value
);
3037 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
3038 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
3039 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, value
);
3042 case OPT_fprofile_info_section
:
3043 opts
->x_profile_info_section
= ".gcov_info";
3046 case OPT_fpatchable_function_entry_
:
3048 HOST_WIDE_INT patch_area_size
, patch_area_start
;
3049 parse_and_check_patch_area (arg
, true, &patch_area_size
,
3054 case OPT_ftree_vectorize
:
3055 /* Automatically sets -ftree-loop-vectorize and
3056 -ftree-slp-vectorize. Nothing more to do here. */
3058 case OPT_fzero_call_used_regs_
:
3059 opts
->x_flag_zero_call_used_regs
3060 = parse_zero_call_used_regs_options (arg
);
3063 case OPT_fshow_column
:
3064 dc
->show_column
= value
;
3067 case OPT_frandom_seed
:
3068 /* The real switch is -fno-random-seed. */
3074 case OPT_frandom_seed_
:
3078 case OPT_fsched_verbose_
:
3079 #ifdef INSN_SCHEDULING
3080 /* Handled with Var in common.opt. */
3086 case OPT_fsched_stalled_insns_
:
3087 opts
->x_flag_sched_stalled_insns
= value
;
3088 if (opts
->x_flag_sched_stalled_insns
== 0)
3089 opts
->x_flag_sched_stalled_insns
= -1;
3092 case OPT_fsched_stalled_insns_dep_
:
3093 opts
->x_flag_sched_stalled_insns_dep
= value
;
3096 case OPT_fstack_check_
:
3097 if (!strcmp (arg
, "no"))
3098 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
3099 else if (!strcmp (arg
, "generic"))
3100 /* This is the old stack checking method. */
3101 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
3102 ? FULL_BUILTIN_STACK_CHECK
3103 : GENERIC_STACK_CHECK
;
3104 else if (!strcmp (arg
, "specific"))
3105 /* This is the new stack checking method. */
3106 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
3107 ? FULL_BUILTIN_STACK_CHECK
3108 : STACK_CHECK_STATIC_BUILTIN
3109 ? STATIC_BUILTIN_STACK_CHECK
3110 : GENERIC_STACK_CHECK
;
3112 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
3115 case OPT_fstack_limit
:
3116 /* The real switch is -fno-stack-limit. */
3122 case OPT_fstack_limit_register_
:
3123 case OPT_fstack_limit_symbol_
:
3127 case OPT_fstack_usage
:
3128 opts
->x_flag_stack_usage
= value
;
3129 opts
->x_flag_stack_usage_info
= value
!= 0;
3133 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
3141 set_debug_level (BTF_DEBUG
, false, arg
, opts
, opts_set
, loc
);
3142 /* set the debug level to level 2, but if already at level 3,
3144 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
3145 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3149 set_debug_level (CTF_DEBUG
, false, arg
, opts
, opts_set
, loc
);
3150 /* CTF generation feeds off DWARF dies. For optimal CTF, switch debug
3151 info level to 2. If off or at level 1, set it to level 2, but if
3152 already at level 3, don't lower it. */
3153 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
3154 && opts
->x_ctf_debug_info_level
> CTFINFO_LEVEL_NONE
)
3155 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3159 if (arg
&& strlen (arg
) != 0)
3161 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
3162 "use %<-gdwarf-%s%> for DWARF version "
3163 "or %<-gdwarf%> %<-g%s%> for debug level", arg
, arg
, arg
);
3167 value
= opts
->x_dwarf_version
;
3171 if (value
< 2 || value
> 5)
3172 error_at (loc
, "dwarf version %wu is not supported", value
);
3174 opts
->x_dwarf_version
= value
;
3175 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
3179 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
3183 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
3188 /* Handled completely via specs. */
3191 case OPT_pedantic_errors
:
3192 dc
->pedantic_errors
= 1;
3193 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
3195 handlers
, opts
, opts_set
,
3200 opts
->x_flag_lto
= value
? "" : NULL
;
3204 if (strcmp (arg
, "none") != 0
3205 && strcmp (arg
, "jobserver") != 0
3206 && strcmp (arg
, "auto") != 0
3209 "unrecognized argument to %<-flto=%> option: %qs", arg
);
3213 dc
->dc_inhibit_warnings
= true;
3216 case OPT_fmax_errors_
:
3217 dc
->max_errors
= value
;
3220 case OPT_fuse_ld_bfd
:
3221 case OPT_fuse_ld_gold
:
3222 case OPT_fuse_ld_lld
:
3223 case OPT_fuse_ld_mold
:
3224 case OPT_fuse_linker_plugin
:
3225 /* No-op. Used by the driver and passed to us because it starts with f.*/
3230 opts
->x_flag_trapv
= 0;
3235 opts
->x_flag_wrapv
= 0;
3238 case OPT_fstrict_overflow
:
3239 opts
->x_flag_wrapv
= !value
;
3240 opts
->x_flag_wrapv_pointer
= !value
;
3242 opts
->x_flag_trapv
= 0;
3246 opts
->x_flag_ipa_icf_functions
= value
;
3247 opts
->x_flag_ipa_icf_variables
= value
;
3250 case OPT_falign_loops_
:
3251 check_alignment_argument (loc
, arg
, "loops",
3252 &opts
->x_flag_align_loops
,
3253 &opts
->x_str_align_loops
);
3256 case OPT_falign_jumps_
:
3257 check_alignment_argument (loc
, arg
, "jumps",
3258 &opts
->x_flag_align_jumps
,
3259 &opts
->x_str_align_jumps
);
3262 case OPT_falign_labels_
:
3263 check_alignment_argument (loc
, arg
, "labels",
3264 &opts
->x_flag_align_labels
,
3265 &opts
->x_str_align_labels
);
3268 case OPT_falign_functions_
:
3269 check_alignment_argument (loc
, arg
, "functions",
3270 &opts
->x_flag_align_functions
,
3271 &opts
->x_str_align_functions
);
3275 /* It is documented that we silently ignore silly values. */
3276 if (value
>= 1 && value
<= 100)
3277 dc
->tabstop
= value
;
3280 case OPT_freport_bug
:
3281 dc
->report_bug
= value
;
3284 case OPT_fmultiflags
:
3285 gcc_checking_assert (lang_mask
== CL_DRIVER
);
3289 /* If the flag was handled in a standard way, assume the lack of
3290 processing here is intentional. */
3291 gcc_assert (option_flag_var (scode
, opts
));
3295 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
3300 /* Used to set the level of strict aliasing warnings in OPTS,
3301 when no level is specified (i.e., when -Wstrict-aliasing, and not
3302 -Wstrict-aliasing=level was given).
3303 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
3304 and 0 otherwise. After calling this function, wstrict_aliasing will be
3305 set to the default value of -Wstrict_aliasing=level, currently 3. */
3307 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
3309 gcc_assert (onoff
== 0 || onoff
== 1);
3311 opts
->x_warn_strict_aliasing
= 3;
3313 opts
->x_warn_strict_aliasing
= 0;
3316 /* The following routines are useful in setting all the flags that
3317 -ffast-math and -fno-fast-math imply. */
3319 set_fast_math_flags (struct gcc_options
*opts
, int set
)
3321 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
3323 opts
->x_flag_unsafe_math_optimizations
= set
;
3324 set_unsafe_math_optimizations_flags (opts
, set
);
3326 if (!opts
->frontend_set_flag_finite_math_only
)
3327 opts
->x_flag_finite_math_only
= set
;
3328 if (!opts
->frontend_set_flag_errno_math
)
3329 opts
->x_flag_errno_math
= !set
;
3332 if (opts
->frontend_set_flag_excess_precision
== EXCESS_PRECISION_DEFAULT
)
3333 opts
->x_flag_excess_precision
3334 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
3335 if (!opts
->frontend_set_flag_signaling_nans
)
3336 opts
->x_flag_signaling_nans
= 0;
3337 if (!opts
->frontend_set_flag_rounding_math
)
3338 opts
->x_flag_rounding_math
= 0;
3339 if (!opts
->frontend_set_flag_cx_limited_range
)
3340 opts
->x_flag_cx_limited_range
= 1;
3344 /* When -funsafe-math-optimizations is set the following
3345 flags are set as well. */
3347 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
3349 if (!opts
->frontend_set_flag_trapping_math
)
3350 opts
->x_flag_trapping_math
= !set
;
3351 if (!opts
->frontend_set_flag_signed_zeros
)
3352 opts
->x_flag_signed_zeros
= !set
;
3353 if (!opts
->frontend_set_flag_associative_math
)
3354 opts
->x_flag_associative_math
= set
;
3355 if (!opts
->frontend_set_flag_reciprocal_math
)
3356 opts
->x_flag_reciprocal_math
= set
;
3359 /* Return true iff flags in OPTS are set as if -ffast-math. */
3361 fast_math_flags_set_p (const struct gcc_options
*opts
)
3363 return (!opts
->x_flag_trapping_math
3364 && opts
->x_flag_unsafe_math_optimizations
3365 && opts
->x_flag_finite_math_only
3366 && !opts
->x_flag_signed_zeros
3367 && !opts
->x_flag_errno_math
3368 && opts
->x_flag_excess_precision
== EXCESS_PRECISION_FAST
);
3371 /* Return true iff flags are set as if -ffast-math but using the flags stored
3372 in the struct cl_optimization structure. */
3374 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
3376 return (!opt
->x_flag_trapping_math
3377 && opt
->x_flag_unsafe_math_optimizations
3378 && opt
->x_flag_finite_math_only
3379 && !opt
->x_flag_signed_zeros
3380 && !opt
->x_flag_errno_math
);
3383 /* Handle a debug output -g switch for options OPTS
3384 (OPTS_SET->x_write_symbols storing whether a debug format was passed
3385 explicitly), location LOC. EXTENDED is true or false to support
3386 extended output (2 is special and means "-ggdb" was given). */
3388 set_debug_level (uint32_t dinfo
, int extended
, const char *arg
,
3389 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
3392 if (dinfo
== NO_DEBUG
)
3394 if (opts
->x_write_symbols
== NO_DEBUG
)
3396 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
3400 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
3401 if (opts
->x_write_symbols
& CTF_DEBUG
)
3402 opts
->x_write_symbols
|= DWARF2_DEBUG
;
3404 opts
->x_write_symbols
= DWARF2_DEBUG
;
3408 if (opts
->x_write_symbols
== NO_DEBUG
)
3409 warning_at (loc
, 0, "target system does not support debug output");
3411 else if ((opts
->x_write_symbols
& CTF_DEBUG
)
3412 || (opts
->x_write_symbols
& BTF_DEBUG
))
3414 opts
->x_write_symbols
|= DWARF2_DEBUG
;
3415 opts_set
->x_write_symbols
|= DWARF2_DEBUG
;
3420 /* Make and retain the choice if both CTF and DWARF debug info are to
3422 if (((dinfo
== DWARF2_DEBUG
) || (dinfo
== CTF_DEBUG
))
3423 && ((opts
->x_write_symbols
== (DWARF2_DEBUG
|CTF_DEBUG
))
3424 || (opts
->x_write_symbols
== DWARF2_DEBUG
)
3425 || (opts
->x_write_symbols
== CTF_DEBUG
)))
3427 opts
->x_write_symbols
|= dinfo
;
3428 opts_set
->x_write_symbols
|= dinfo
;
3430 /* However, CTF and BTF are not allowed together at this time. */
3431 else if (((dinfo
== DWARF2_DEBUG
) || (dinfo
== BTF_DEBUG
))
3432 && ((opts
->x_write_symbols
== (DWARF2_DEBUG
|BTF_DEBUG
))
3433 || (opts
->x_write_symbols
== DWARF2_DEBUG
)
3434 || (opts
->x_write_symbols
== BTF_DEBUG
)))
3436 opts
->x_write_symbols
|= dinfo
;
3437 opts_set
->x_write_symbols
|= dinfo
;
3441 /* Does it conflict with an already selected debug format? */
3442 if (opts_set
->x_write_symbols
!= NO_DEBUG
3443 && opts
->x_write_symbols
!= NO_DEBUG
3444 && dinfo
!= opts
->x_write_symbols
)
3446 gcc_assert (debug_set_count (dinfo
) <= 1);
3447 error_at (loc
, "debug format %qs conflicts with prior selection",
3448 debug_type_names
[debug_set_to_format (dinfo
)]);
3450 opts
->x_write_symbols
= dinfo
;
3451 opts_set
->x_write_symbols
= dinfo
;
3455 if (dinfo
!= BTF_DEBUG
)
3457 /* A debug flag without a level defaults to level 2.
3458 If off or at level 1, set it to level 2, but if already
3459 at level 3, don't lower it. */
3462 if (dinfo
== CTF_DEBUG
)
3463 opts
->x_ctf_debug_info_level
= CTFINFO_LEVEL_NORMAL
;
3464 else if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
3465 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3469 int argval
= integral_argument (arg
);
3471 error_at (loc
, "unrecognized debug output level %qs", arg
);
3472 else if (argval
> 3)
3473 error_at (loc
, "debug output level %qs is too high", arg
);
3476 if (dinfo
== CTF_DEBUG
)
3477 opts
->x_ctf_debug_info_level
3478 = (enum ctf_debug_info_levels
) argval
;
3480 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
3484 else if (*arg
!= '\0')
3485 error_at (loc
, "unrecognized btf debug output level %qs", arg
);
3488 /* Arrange to dump core on error for diagnostic context DC. (The
3489 regular error message is still printed first, except in the case of
3493 setup_core_dumping (diagnostic_context
*dc
)
3496 signal (SIGABRT
, SIG_DFL
);
3498 #if defined(HAVE_SETRLIMIT)
3501 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
3502 fatal_error (input_location
, "getting core file size maximum limit: %m");
3503 rlim
.rlim_cur
= rlim
.rlim_max
;
3504 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
3505 fatal_error (input_location
,
3506 "setting core file size limit to maximum: %m");
3509 diagnostic_abort_on_error (dc
);
3512 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
3513 diagnostic context DC. */
3516 decode_d_option (const char *arg
, struct gcc_options
*opts
,
3517 location_t loc
, diagnostic_context
*dc
)
3525 opts
->x_flag_debug_asm
= 1;
3528 opts
->x_flag_print_asm_name
= 1;
3531 opts
->x_flag_dump_rtl_in_asm
= 1;
3532 opts
->x_flag_print_asm_name
= 1;
3535 opts
->x_rtl_dump_and_exit
= 1;
3537 case 'D': /* These are handled by the preprocessor. */
3544 setup_core_dumping (dc
);
3547 opts
->x_flag_dump_all_passed
= true;
3551 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
3556 /* Enable (or disable if VALUE is 0) a warning option ARG (language
3557 mask LANG_MASK, option handlers HANDLERS) as an error for option
3558 structures OPTS and OPTS_SET, diagnostic context DC (possibly
3559 NULL), location LOC. This is used by -Werror=. */
3562 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
3563 const struct cl_option_handlers
*handlers
,
3564 struct gcc_options
*opts
,
3565 struct gcc_options
*opts_set
,
3566 location_t loc
, diagnostic_context
*dc
)
3571 new_option
= XNEWVEC (char, strlen (arg
) + 2);
3572 new_option
[0] = 'W';
3573 strcpy (new_option
+ 1, arg
);
3574 option_index
= find_opt (new_option
, lang_mask
);
3575 if (option_index
== OPT_SPECIAL_unknown
)
3578 const char *hint
= op
.suggest_option (new_option
);
3580 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>;"
3581 " did you mean %<-%s%>?", value
? "" : "no-",
3582 arg
, new_option
, hint
);
3584 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>",
3585 value
? "" : "no-", arg
, new_option
);
3587 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
3588 error_at (loc
, "%<-Werror=%s%>: %<-%s%> is not an option that "
3589 "controls warnings", arg
, new_option
);
3592 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
3593 const char *arg
= NULL
;
3595 if (cl_options
[option_index
].flags
& CL_JOINED
)
3596 arg
= new_option
+ cl_options
[option_index
].opt_len
;
3597 control_warning_option (option_index
, (int) kind
, arg
, value
,
3599 handlers
, opts
, opts_set
, dc
);
3604 /* Return malloced memory for the name of the option OPTION_INDEX
3605 which enabled a diagnostic (context CONTEXT), originally of type
3606 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
3610 option_name (diagnostic_context
*context
, int option_index
,
3611 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
3615 /* A warning classified as an error. */
3616 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
3617 && diag_kind
== DK_ERROR
)
3618 return concat (cl_options
[OPT_Werror_
].opt_text
,
3619 /* Skip over "-W". */
3620 cl_options
[option_index
].opt_text
+ 2,
3622 /* A warning with option. */
3624 return xstrdup (cl_options
[option_index
].opt_text
);
3626 /* A warning without option classified as an error. */
3627 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
3628 || diag_kind
== DK_WARNING
)
3629 && context
->warning_as_error_requested
)
3630 return xstrdup (cl_options
[OPT_Werror
].opt_text
);
3635 /* Get the page within the documentation for this option. */
3638 get_option_html_page (int option_index
)
3640 const cl_option
*cl_opt
= &cl_options
[option_index
];
3642 /* Analyzer options are on their own page. */
3643 if (strstr (cl_opt
->opt_text
, "analyzer-"))
3644 return "gcc/Static-Analyzer-Options.html";
3646 /* Handle -flto= option. */
3647 if (strstr (cl_opt
->opt_text
, "flto"))
3648 return "gcc/Optimize-Options.html";
3651 if ((cl_opt
->flags
& CL_Fortran
) != 0
3652 /* If it is option common to both C/C++ and Fortran, it is documented
3653 in gcc/ rather than gfortran/ docs. */
3654 && (cl_opt
->flags
& CL_C
) == 0
3656 && (cl_opt
->flags
& CL_CXX
) == 0
3659 return "gfortran/Error-and-Warning-Options.html";
3662 return "gcc/Warning-Options.html";
3665 /* Return malloced memory for a URL describing the option OPTION_INDEX
3666 which enabled a diagnostic (context CONTEXT). */
3669 get_option_url (diagnostic_context
*, int option_index
)
3672 return concat (/* DOCUMENTATION_ROOT_URL should be supplied via -D by
3673 the Makefile (see --with-documentation-root-url), and
3674 should have a trailing slash. */
3675 DOCUMENTATION_ROOT_URL
,
3677 /* get_option_html_page will return something like
3678 "gcc/Warning-Options.html". */
3679 get_option_html_page (option_index
),
3681 /* Expect an anchor of the form "index-Wfoo" e.g.
3682 <a name="index-Wformat"></a>, and thus an id within
3683 the URL of "#index-Wformat". */
3684 "#index", cl_options
[option_index
].opt_text
,
3690 /* Return a heap allocated producer with command line options. */
3693 gen_command_line_string (cl_decoded_option
*options
,
3694 unsigned int options_count
)
3696 auto_vec
<const char *> switches
;
3697 char *options_string
, *tail
;
3701 for (unsigned i
= 0; i
< options_count
; i
++)
3702 switch (options
[i
].opt_index
)
3707 case OPT_dumpbase_ext
:
3717 case OPT_SPECIAL_unknown
:
3718 case OPT_SPECIAL_ignore
:
3719 case OPT_SPECIAL_warn_removed
:
3720 case OPT_SPECIAL_program_name
:
3721 case OPT_SPECIAL_input_file
:
3722 case OPT_grecord_gcc_switches
:
3723 case OPT_frecord_gcc_switches
:
3724 case OPT__output_pch
:
3725 case OPT_fdiagnostics_show_location_
:
3726 case OPT_fdiagnostics_show_option
:
3727 case OPT_fdiagnostics_show_caret
:
3728 case OPT_fdiagnostics_show_labels
:
3729 case OPT_fdiagnostics_show_line_numbers
:
3730 case OPT_fdiagnostics_color_
:
3731 case OPT_fdiagnostics_format_
:
3732 case OPT_fverbose_asm
:
3736 case OPT_nostdinc__
:
3737 case OPT_fpreprocessed
:
3738 case OPT_fltrans_output_list_
:
3739 case OPT_fresolution_
:
3740 case OPT_fdebug_prefix_map_
:
3741 case OPT_fmacro_prefix_map_
:
3742 case OPT_ffile_prefix_map_
:
3743 case OPT_fprofile_prefix_map_
:
3744 case OPT_fcanon_prefix_map
:
3745 case OPT_fcompare_debug
:
3747 case OPT_fchecking_
:
3752 const char *lto_canonical
= "-flto";
3753 switches
.safe_push (lto_canonical
);
3754 len
+= strlen (lto_canonical
) + 1;
3758 if (cl_options
[options
[i
].opt_index
].flags
3759 & CL_NO_DWARF_RECORD
)
3761 gcc_checking_assert (options
[i
].canonical_option
[0][0] == '-');
3762 switch (options
[i
].canonical_option
[0][1])
3769 if (strncmp (options
[i
].canonical_option
[0] + 2,
3776 switches
.safe_push (options
[i
].orig_option_with_args_text
);
3777 len
+= strlen (options
[i
].orig_option_with_args_text
) + 1;
3781 options_string
= XNEWVEC (char, len
+ 1);
3782 tail
= options_string
;
3785 FOR_EACH_VEC_ELT (switches
, i
, p
)
3788 memcpy (tail
, p
, len
);
3790 if (i
!= switches
.length () - 1)
3798 return options_string
;
3801 /* Return a heap allocated producer string including command line options. */
3804 gen_producer_string (const char *language_string
, cl_decoded_option
*options
,
3805 unsigned int options_count
)
3807 char *cmdline
= gen_command_line_string (options
, options_count
);
3808 char *combined
= concat (language_string
, " ", version_string
, " ",
3816 namespace selftest
{
3818 /* Verify that get_option_html_page works as expected. */
3821 test_get_option_html_page ()
3823 ASSERT_STREQ (get_option_html_page (OPT_Wcpp
), "gcc/Warning-Options.html");
3824 ASSERT_STREQ (get_option_html_page (OPT_Wanalyzer_double_free
),
3825 "gcc/Static-Analyzer-Options.html");
3827 ASSERT_STREQ (get_option_html_page (OPT_Wline_truncation
),
3828 "gfortran/Error-and-Warning-Options.html");
3832 /* Verify EnumSet and EnumBitSet requirements. */
3837 for (unsigned i
= 0; i
< cl_options_count
; ++i
)
3838 if (cl_options
[i
].var_type
== CLVC_ENUM
3839 && cl_options
[i
].var_value
!= CLEV_NORMAL
)
3841 const struct cl_enum
*e
= &cl_enums
[cl_options
[i
].var_enum
];
3842 unsigned HOST_WIDE_INT used_sets
= 0;
3843 unsigned HOST_WIDE_INT mask
= 0;
3844 unsigned highest_set
= 0;
3845 for (unsigned j
= 0; e
->values
[j
].arg
; ++j
)
3847 unsigned set
= e
->values
[j
].flags
>> CL_ENUM_SET_SHIFT
;
3848 if (cl_options
[i
].var_value
== CLEV_BITSET
)
3850 /* For EnumBitSet Set shouldn't be used and Value should
3851 be a power of two. */
3852 ASSERT_TRUE (set
== 0);
3853 ASSERT_TRUE (pow2p_hwi (e
->values
[j
].value
));
3856 /* Test that enumerators referenced in EnumSet have all
3857 Set(n) on them within the valid range. */
3858 ASSERT_TRUE (set
>= 1 && set
<= HOST_BITS_PER_WIDE_INT
);
3859 highest_set
= MAX (set
, highest_set
);
3860 used_sets
|= HOST_WIDE_INT_1U
<< (set
- 1);
3862 if (cl_options
[i
].var_value
== CLEV_BITSET
)
3864 /* If there is just one set, no point to using EnumSet. */
3865 ASSERT_TRUE (highest_set
>= 2);
3866 /* Test that there are no gaps in between the sets. */
3867 if (highest_set
== HOST_BITS_PER_WIDE_INT
)
3868 ASSERT_TRUE (used_sets
== HOST_WIDE_INT_M1U
);
3870 ASSERT_TRUE (used_sets
== (HOST_WIDE_INT_1U
<< highest_set
) - 1);
3871 for (unsigned int j
= 1; j
<= highest_set
; ++j
)
3873 unsigned HOST_WIDE_INT this_mask
= 0;
3874 for (unsigned k
= 0; e
->values
[k
].arg
; ++k
)
3876 unsigned set
= e
->values
[j
].flags
>> CL_ENUM_SET_SHIFT
;
3878 this_mask
|= e
->values
[j
].value
;
3880 ASSERT_TRUE ((mask
& this_mask
) == 0);
3886 /* Run all of the selftests within this file. */
3891 test_get_option_html_page ();
3895 } // namespace selftest
3897 #endif /* #if CHECKING_P */