1 /* Command line option handling.
2 Copyright (C) 2002-2022 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"
38 /* In this file all option sets are explicit. */
41 static void set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
);
43 /* Names of fundamental debug info formats indexed by enum
46 const char *const debug_type_names
[] =
48 "none", "stabs", "dwarf-2", "xcoff", "vms", "ctf", "btf"
51 /* Bitmasks of fundamental debug info formats indexed by enum
54 static uint32_t debug_type_masks
[] =
56 NO_DEBUG
, DWARF2_DEBUG
, VMS_DEBUG
,
60 /* Names of the set of debug formats requested by user. Updated and accessed
61 via debug_set_names. */
63 static char df_set_names
[sizeof "none stabs dwarf-2 xcoff vms ctf btf"];
65 /* Get enum debug_info_type of the specified debug format, for error messages.
66 Can be used only for individual debug format types. */
69 debug_set_to_format (uint32_t debug_info_set
)
72 enum debug_info_type dinfo_type
= DINFO_TYPE_NONE
;
73 /* Find first set bit. */
75 idx
= exact_log2 (debug_info_set
& - debug_info_set
);
76 /* Check that only one bit is set, if at all. This function is meant to be
77 used only for vanilla debug_info_set bitmask values, i.e. for individual
78 debug format types upto DINFO_TYPE_MAX. */
79 gcc_assert ((debug_info_set
& (debug_info_set
- 1)) == 0);
80 dinfo_type
= (enum debug_info_type
)idx
;
81 gcc_assert (dinfo_type
<= DINFO_TYPE_MAX
);
85 /* Get the number of debug formats enabled for output. */
88 debug_set_count (uint32_t w_symbols
)
90 unsigned int count
= 0;
94 w_symbols
&= ~ (w_symbols
& - w_symbols
);
99 /* Get the names of the debug formats enabled for output. */
102 debug_set_names (uint32_t w_symbols
)
104 uint32_t df_mask
= 0;
105 /* Reset the string to be returned. */
106 memset (df_set_names
, 0, sizeof (df_set_names
));
107 /* Get the popcount. */
108 int num_set_df
= debug_set_count (w_symbols
);
109 /* Iterate over the debug formats. Add name string for those enabled. */
110 for (int i
= DINFO_TYPE_NONE
; i
<= DINFO_TYPE_MAX
; i
++)
112 df_mask
= debug_type_masks
[i
];
113 if (w_symbols
& df_mask
)
115 strcat (df_set_names
, debug_type_names
[i
]);
118 strcat (df_set_names
, " ");
124 /* No debug formats enabled. */
125 gcc_assert (i
== DINFO_TYPE_NONE
);
126 strcat (df_set_names
, debug_type_names
[i
]);
133 /* Return TRUE iff BTF debug info is enabled. */
138 return (write_symbols
& BTF_DEBUG
);
141 /* Return TRUE iff BTF with CO-RE debug info is enabled. */
144 btf_with_core_debuginfo_p ()
146 return (write_symbols
& BTF_WITH_CORE_DEBUG
);
149 /* Return TRUE iff CTF debug info is enabled. */
154 return (write_symbols
& CTF_DEBUG
);
157 /* Return TRUE iff dwarf2 debug info is enabled. */
160 dwarf_debuginfo_p (struct gcc_options
*opts
)
162 return (opts
->x_write_symbols
& DWARF2_DEBUG
);
165 /* Return true iff the debug info format is to be generated based on DWARF
166 DIEs (like CTF and BTF debug info formats). */
168 bool dwarf_based_debuginfo_p ()
170 return ((write_symbols
& CTF_DEBUG
)
171 || (write_symbols
& BTF_DEBUG
));
174 /* All flag uses below need to explicitely reference the option sets
176 #define global_options DO_NOT_USE
177 #define global_options_set DO_NOT_USE
179 /* Parse the -femit-struct-debug-detailed option value
180 and set the flag variables. */
182 #define MATCH( prefix, string ) \
183 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
184 ? ((string += sizeof prefix - 1), 1) : 0)
187 set_struct_debug_option (struct gcc_options
*opts
, location_t loc
,
190 /* various labels for comparison */
191 static const char dfn_lbl
[] = "dfn:", dir_lbl
[] = "dir:", ind_lbl
[] = "ind:";
192 static const char ord_lbl
[] = "ord:", gen_lbl
[] = "gen:";
193 static const char none_lbl
[] = "none", any_lbl
[] = "any";
194 static const char base_lbl
[] = "base", sys_lbl
[] = "sys";
196 enum debug_struct_file files
= DINFO_STRUCT_FILE_ANY
;
197 /* Default is to apply to as much as possible. */
198 enum debug_info_usage usage
= DINFO_USAGE_NUM_ENUMS
;
199 int ord
= 1, gen
= 1;
202 if (MATCH (dfn_lbl
, spec
))
203 usage
= DINFO_USAGE_DFN
;
204 else if (MATCH (dir_lbl
, spec
))
205 usage
= DINFO_USAGE_DIR_USE
;
206 else if (MATCH (ind_lbl
, spec
))
207 usage
= DINFO_USAGE_IND_USE
;
209 /* Generics or not? */
210 if (MATCH (ord_lbl
, spec
))
212 else if (MATCH (gen_lbl
, spec
))
215 /* What allowable environment? */
216 if (MATCH (none_lbl
, spec
))
217 files
= DINFO_STRUCT_FILE_NONE
;
218 else if (MATCH (any_lbl
, spec
))
219 files
= DINFO_STRUCT_FILE_ANY
;
220 else if (MATCH (sys_lbl
, spec
))
221 files
= DINFO_STRUCT_FILE_SYS
;
222 else if (MATCH (base_lbl
, spec
))
223 files
= DINFO_STRUCT_FILE_BASE
;
226 "argument %qs to %<-femit-struct-debug-detailed%> "
230 /* Effect the specification. */
231 if (usage
== DINFO_USAGE_NUM_ENUMS
)
235 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DFN
] = files
;
236 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
] = files
;
237 opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
] = files
;
241 opts
->x_debug_struct_generic
[DINFO_USAGE_DFN
] = files
;
242 opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
] = files
;
243 opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
] = files
;
249 opts
->x_debug_struct_ordinary
[usage
] = files
;
251 opts
->x_debug_struct_generic
[usage
] = files
;
255 set_struct_debug_option (opts
, loc
, spec
+1);
258 /* No more -femit-struct-debug-detailed specifications.
262 "argument %qs to %<-femit-struct-debug-detailed%> unknown",
264 if (opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
]
265 < opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
]
266 || opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
]
267 < opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
])
269 "%<-femit-struct-debug-detailed=dir:...%> must allow "
270 "at least as much as "
271 "%<-femit-struct-debug-detailed=ind:...%>");
275 /* Strip off a legitimate source ending from the input string NAME of
276 length LEN. Rather than having to know the names used by all of
277 our front ends, we strip off an ending of a period followed by
278 up to fource characters. (C++ uses ".cpp".) */
281 strip_off_ending (char *name
, int len
)
284 for (i
= 2; i
< 5 && len
> i
; i
++)
286 if (name
[len
- i
] == '.')
288 name
[len
- i
] = '\0';
294 /* Find the base name of a path, stripping off both directories and
295 a single final extension. */
297 base_of_path (const char *path
, const char **base_out
)
299 const char *base
= path
;
301 const char *p
= path
;
305 if (IS_DIR_SEPARATOR (c
))
320 /* What to print when a switch has no documentation. */
321 static const char undocumented_msg
[] = N_("This option lacks documentation.");
322 static const char use_diagnosed_msg
[] = N_("Uses of this option are diagnosed.");
324 typedef char *char_p
; /* For DEF_VEC_P. */
326 static void set_debug_level (uint32_t dinfo
, int extended
,
327 const char *arg
, struct gcc_options
*opts
,
328 struct gcc_options
*opts_set
,
330 static void set_fast_math_flags (struct gcc_options
*opts
, int set
);
331 static void decode_d_option (const char *arg
, struct gcc_options
*opts
,
332 location_t loc
, diagnostic_context
*dc
);
333 static void set_unsafe_math_optimizations_flags (struct gcc_options
*opts
,
335 static void enable_warning_as_error (const char *arg
, int value
,
336 unsigned int lang_mask
,
337 const struct cl_option_handlers
*handlers
,
338 struct gcc_options
*opts
,
339 struct gcc_options
*opts_set
,
341 diagnostic_context
*dc
);
343 /* Handle a back-end option; arguments and return value as for
347 target_handle_option (struct gcc_options
*opts
,
348 struct gcc_options
*opts_set
,
349 const struct cl_decoded_option
*decoded
,
350 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
352 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
353 diagnostic_context
*dc
, void (*) (void))
355 gcc_assert (dc
== global_dc
);
356 gcc_assert (kind
== DK_UNSPECIFIED
);
357 return targetm_common
.handle_option (opts
, opts_set
, decoded
, loc
);
360 /* Add comma-separated strings to a char_p vector. */
363 add_comma_separated_to_vector (void **pvec
, const char *arg
)
369 vec
<char_p
> *v
= (vec
<char_p
> *) *pvec
;
371 vec_check_alloc (v
, 1);
373 /* We never free this string. */
386 v
->safe_push (token_start
);
389 if (*r
== '\\' && r
[1] == ',')
399 if (*token_start
!= '\0')
400 v
->safe_push (token_start
);
405 /* Initialize opts_obstack. */
408 init_opts_obstack (void)
410 gcc_obstack_init (&opts_obstack
);
413 /* Initialize OPTS and OPTS_SET before using them in parsing options. */
416 init_options_struct (struct gcc_options
*opts
, struct gcc_options
*opts_set
)
418 /* Ensure that opts_obstack has already been initialized by the time
419 that we initialize any gcc_options instances (PR jit/68446). */
420 gcc_assert (opts_obstack
.chunk_size
> 0);
422 *opts
= global_options_init
;
425 memset (opts_set
, 0, sizeof (*opts_set
));
427 /* Initialize whether `char' is signed. */
428 opts
->x_flag_signed_char
= DEFAULT_SIGNED_CHAR
;
429 /* Set this to a special "uninitialized" value. The actual default
430 is set after target options have been processed. */
431 opts
->x_flag_short_enums
= 2;
433 /* Initialize target_flags before default_options_optimization
434 so the latter can modify it. */
435 opts
->x_target_flags
= targetm_common
.default_target_flags
;
437 /* Some targets have ABI-specified unwind tables. */
438 opts
->x_flag_unwind_tables
= targetm_common
.unwind_tables_default
;
440 /* Some targets have other target-specific initialization. */
441 targetm_common
.option_init_struct (opts
);
444 /* If indicated by the optimization level LEVEL (-Os if SIZE is set,
445 -Ofast if FAST is set, -Og if DEBUG is set), apply the option DEFAULT_OPT
446 to OPTS and OPTS_SET, diagnostic context DC, location LOC, with language
447 mask LANG_MASK and option handlers HANDLERS. */
450 maybe_default_option (struct gcc_options
*opts
,
451 struct gcc_options
*opts_set
,
452 const struct default_options
*default_opt
,
453 int level
, bool size
, bool fast
, bool debug
,
454 unsigned int lang_mask
,
455 const struct cl_option_handlers
*handlers
,
457 diagnostic_context
*dc
)
459 const struct cl_option
*option
= &cl_options
[default_opt
->opt_index
];
463 gcc_assert (level
== 2);
465 gcc_assert (level
== 3);
467 gcc_assert (level
== 1);
469 switch (default_opt
->levels
)
475 case OPT_LEVELS_0_ONLY
:
476 enabled
= (level
== 0);
479 case OPT_LEVELS_1_PLUS
:
480 enabled
= (level
>= 1);
483 case OPT_LEVELS_1_PLUS_SPEED_ONLY
:
484 enabled
= (level
>= 1 && !size
&& !debug
);
487 case OPT_LEVELS_1_PLUS_NOT_DEBUG
:
488 enabled
= (level
>= 1 && !debug
);
491 case OPT_LEVELS_2_PLUS
:
492 enabled
= (level
>= 2);
495 case OPT_LEVELS_2_PLUS_SPEED_ONLY
:
496 enabled
= (level
>= 2 && !size
&& !debug
);
499 case OPT_LEVELS_3_PLUS
:
500 enabled
= (level
>= 3);
503 case OPT_LEVELS_3_PLUS_AND_SIZE
:
504 enabled
= (level
>= 3 || size
);
507 case OPT_LEVELS_SIZE
:
511 case OPT_LEVELS_FAST
:
515 case OPT_LEVELS_NONE
:
521 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
522 default_opt
->arg
, default_opt
->value
,
523 lang_mask
, DK_UNSPECIFIED
, loc
,
525 else if (default_opt
->arg
== NULL
526 && !option
->cl_reject_negative
527 && !(option
->flags
& CL_PARAMS
))
528 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
529 default_opt
->arg
, !default_opt
->value
,
530 lang_mask
, DK_UNSPECIFIED
, loc
,
534 /* As indicated by the optimization level LEVEL (-Os if SIZE is set,
535 -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
536 OPTS and OPTS_SET, diagnostic context DC, location LOC, with
537 language mask LANG_MASK and option handlers HANDLERS. */
540 maybe_default_options (struct gcc_options
*opts
,
541 struct gcc_options
*opts_set
,
542 const struct default_options
*default_opts
,
543 int level
, bool size
, bool fast
, bool debug
,
544 unsigned int lang_mask
,
545 const struct cl_option_handlers
*handlers
,
547 diagnostic_context
*dc
)
551 for (i
= 0; default_opts
[i
].levels
!= OPT_LEVELS_NONE
; i
++)
552 maybe_default_option (opts
, opts_set
, &default_opts
[i
],
553 level
, size
, fast
, debug
,
554 lang_mask
, handlers
, loc
, dc
);
557 /* Table of options enabled by default at different levels.
558 Please keep this list sorted by level and alphabetized within
559 each level; this makes it easier to keep the documentation
562 static const struct default_options default_options_table
[] =
564 /* -O1 and -Og optimizations. */
565 { OPT_LEVELS_1_PLUS
, OPT_fcombine_stack_adjustments
, NULL
, 1 },
566 { OPT_LEVELS_1_PLUS
, OPT_fcompare_elim
, NULL
, 1 },
567 { OPT_LEVELS_1_PLUS
, OPT_fcprop_registers
, NULL
, 1 },
568 { OPT_LEVELS_1_PLUS
, OPT_fdefer_pop
, NULL
, 1 },
569 { OPT_LEVELS_1_PLUS
, OPT_fforward_propagate
, NULL
, 1 },
570 { OPT_LEVELS_1_PLUS
, OPT_fguess_branch_probability
, NULL
, 1 },
571 { OPT_LEVELS_1_PLUS
, OPT_fipa_profile
, NULL
, 1 },
572 { OPT_LEVELS_1_PLUS
, OPT_fipa_pure_const
, NULL
, 1 },
573 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference
, NULL
, 1 },
574 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference_addressable
, NULL
, 1 },
575 { OPT_LEVELS_1_PLUS
, OPT_fmerge_constants
, NULL
, 1 },
576 { OPT_LEVELS_1_PLUS
, OPT_fomit_frame_pointer
, NULL
, 1 },
577 { OPT_LEVELS_1_PLUS
, OPT_freorder_blocks
, NULL
, 1 },
578 { OPT_LEVELS_1_PLUS
, OPT_fshrink_wrap
, NULL
, 1 },
579 { OPT_LEVELS_1_PLUS
, OPT_fsplit_wide_types
, NULL
, 1 },
580 { OPT_LEVELS_1_PLUS
, OPT_fthread_jumps
, NULL
, 1 },
581 { OPT_LEVELS_1_PLUS
, OPT_ftree_builtin_call_dce
, NULL
, 1 },
582 { OPT_LEVELS_1_PLUS
, OPT_ftree_ccp
, NULL
, 1 },
583 { OPT_LEVELS_1_PLUS
, OPT_ftree_ch
, NULL
, 1 },
584 { OPT_LEVELS_1_PLUS
, OPT_ftree_coalesce_vars
, NULL
, 1 },
585 { OPT_LEVELS_1_PLUS
, OPT_ftree_copy_prop
, NULL
, 1 },
586 { OPT_LEVELS_1_PLUS
, OPT_ftree_dce
, NULL
, 1 },
587 { OPT_LEVELS_1_PLUS
, OPT_ftree_dominator_opts
, NULL
, 1 },
588 { OPT_LEVELS_1_PLUS
, OPT_ftree_fre
, NULL
, 1 },
589 { OPT_LEVELS_1_PLUS
, OPT_ftree_sink
, NULL
, 1 },
590 { OPT_LEVELS_1_PLUS
, OPT_ftree_slsr
, NULL
, 1 },
591 { OPT_LEVELS_1_PLUS
, OPT_ftree_ter
, NULL
, 1 },
592 { OPT_LEVELS_1_PLUS
, OPT_fvar_tracking
, NULL
, 1 },
594 /* -O1 (and not -Og) optimizations. */
595 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fbranch_count_reg
, NULL
, 1 },
597 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fdelayed_branch
, NULL
, 1 },
599 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fdse
, NULL
, 1 },
600 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion
, NULL
, 1 },
601 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion2
, NULL
, 1 },
602 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_finline_functions_called_once
, NULL
, 1 },
603 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_invariants
, NULL
, 1 },
604 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_stores
, NULL
, 1 },
605 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fssa_phiopt
, NULL
, 1 },
606 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fipa_modref
, NULL
, 1 },
607 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_bit_ccp
, NULL
, 1 },
608 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_dse
, NULL
, 1 },
609 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_pta
, NULL
, 1 },
610 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_sra
, NULL
, 1 },
612 /* -O2 and -Os optimizations. */
613 { OPT_LEVELS_2_PLUS
, OPT_fcaller_saves
, NULL
, 1 },
614 { OPT_LEVELS_2_PLUS
, OPT_fcode_hoisting
, NULL
, 1 },
615 { OPT_LEVELS_2_PLUS
, OPT_fcrossjumping
, NULL
, 1 },
616 { OPT_LEVELS_2_PLUS
, OPT_fcse_follow_jumps
, NULL
, 1 },
617 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize
, NULL
, 1 },
618 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize_speculatively
, NULL
, 1 },
619 { OPT_LEVELS_2_PLUS
, OPT_fexpensive_optimizations
, NULL
, 1 },
620 { OPT_LEVELS_2_PLUS
, OPT_fgcse
, NULL
, 1 },
621 { OPT_LEVELS_2_PLUS
, OPT_fhoist_adjacent_loads
, NULL
, 1 },
622 { OPT_LEVELS_2_PLUS
, OPT_findirect_inlining
, NULL
, 1 },
623 { OPT_LEVELS_2_PLUS
, OPT_finline_small_functions
, NULL
, 1 },
624 { OPT_LEVELS_2_PLUS
, OPT_fipa_bit_cp
, NULL
, 1 },
625 { OPT_LEVELS_2_PLUS
, OPT_fipa_cp
, NULL
, 1 },
626 { OPT_LEVELS_2_PLUS
, OPT_fipa_icf
, NULL
, 1 },
627 { OPT_LEVELS_2_PLUS
, OPT_fipa_ra
, NULL
, 1 },
628 { OPT_LEVELS_2_PLUS
, OPT_fipa_sra
, NULL
, 1 },
629 { OPT_LEVELS_2_PLUS
, OPT_fipa_vrp
, NULL
, 1 },
630 { OPT_LEVELS_2_PLUS
, OPT_fisolate_erroneous_paths_dereference
, NULL
, 1 },
631 { OPT_LEVELS_2_PLUS
, OPT_flra_remat
, NULL
, 1 },
632 { OPT_LEVELS_2_PLUS
, OPT_foptimize_sibling_calls
, NULL
, 1 },
633 { OPT_LEVELS_2_PLUS
, OPT_fpartial_inlining
, NULL
, 1 },
634 { OPT_LEVELS_2_PLUS
, OPT_fpeephole2
, NULL
, 1 },
635 { OPT_LEVELS_2_PLUS
, OPT_freorder_functions
, NULL
, 1 },
636 { OPT_LEVELS_2_PLUS
, OPT_frerun_cse_after_loop
, NULL
, 1 },
637 #ifdef INSN_SCHEDULING
638 { OPT_LEVELS_2_PLUS
, OPT_fschedule_insns2
, NULL
, 1 },
640 { OPT_LEVELS_2_PLUS
, OPT_fstrict_aliasing
, NULL
, 1 },
641 { OPT_LEVELS_2_PLUS
, OPT_fstore_merging
, NULL
, 1 },
642 { OPT_LEVELS_2_PLUS
, OPT_ftree_pre
, NULL
, 1 },
643 { OPT_LEVELS_2_PLUS
, OPT_ftree_switch_conversion
, NULL
, 1 },
644 { OPT_LEVELS_2_PLUS
, OPT_ftree_tail_merge
, NULL
, 1 },
645 { OPT_LEVELS_2_PLUS
, OPT_ftree_vrp
, NULL
, 1 },
646 { OPT_LEVELS_2_PLUS
, OPT_fvect_cost_model_
, NULL
,
647 VECT_COST_MODEL_VERY_CHEAP
},
648 { OPT_LEVELS_2_PLUS
, OPT_finline_functions
, NULL
, 1 },
649 { OPT_LEVELS_2_PLUS
, OPT_ftree_loop_distribute_patterns
, NULL
, 1 },
651 /* -O2 and above optimizations, but not -Os or -Og. */
652 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_functions
, NULL
, 1 },
653 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_jumps
, NULL
, 1 },
654 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_labels
, NULL
, 1 },
655 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_loops
, NULL
, 1 },
656 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_foptimize_strlen
, NULL
, 1 },
657 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_freorder_blocks_algorithm_
, NULL
,
658 REORDER_BLOCKS_ALGORITHM_STC
},
659 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_ftree_loop_vectorize
, NULL
, 1 },
660 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_ftree_slp_vectorize
, NULL
, 1 },
661 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_fopenmp_target_simd_clone_
, NULL
,
662 OMP_TARGET_SIMD_CLONE_NOHOST
},
663 #ifdef INSN_SCHEDULING
664 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
665 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_fschedule_insns
, NULL
, 1 },
668 /* -O3 and -Os optimizations. */
670 /* -O3 optimizations. */
671 { OPT_LEVELS_3_PLUS
, OPT_fgcse_after_reload
, NULL
, 1 },
672 { OPT_LEVELS_3_PLUS
, OPT_fipa_cp_clone
, NULL
, 1 },
673 { OPT_LEVELS_3_PLUS
, OPT_floop_interchange
, NULL
, 1 },
674 { OPT_LEVELS_3_PLUS
, OPT_floop_unroll_and_jam
, NULL
, 1 },
675 { OPT_LEVELS_3_PLUS
, OPT_fpeel_loops
, NULL
, 1 },
676 { OPT_LEVELS_3_PLUS
, OPT_fpredictive_commoning
, NULL
, 1 },
677 { OPT_LEVELS_3_PLUS
, OPT_fsplit_loops
, NULL
, 1 },
678 { OPT_LEVELS_3_PLUS
, OPT_fsplit_paths
, NULL
, 1 },
679 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribution
, NULL
, 1 },
680 { OPT_LEVELS_3_PLUS
, OPT_ftree_partial_pre
, NULL
, 1 },
681 { OPT_LEVELS_3_PLUS
, OPT_funswitch_loops
, NULL
, 1 },
682 { OPT_LEVELS_3_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_DYNAMIC
},
683 { OPT_LEVELS_3_PLUS
, OPT_fversion_loops_for_strides
, NULL
, 1 },
685 /* -O3 parameters. */
686 { OPT_LEVELS_3_PLUS
, OPT__param_max_inline_insns_auto_
, NULL
, 30 },
687 { OPT_LEVELS_3_PLUS
, OPT__param_early_inlining_insns_
, NULL
, 14 },
688 { OPT_LEVELS_3_PLUS
, OPT__param_inline_heuristics_hint_percent_
, NULL
, 600 },
689 { OPT_LEVELS_3_PLUS
, OPT__param_inline_min_speedup_
, NULL
, 15 },
690 { OPT_LEVELS_3_PLUS
, OPT__param_max_inline_insns_single_
, NULL
, 200 },
692 /* -Ofast adds optimizations to -O3. */
693 { OPT_LEVELS_FAST
, OPT_ffast_math
, NULL
, 1 },
694 { OPT_LEVELS_FAST
, OPT_fallow_store_data_races
, NULL
, 1 },
695 { OPT_LEVELS_FAST
, OPT_fsemantic_interposition
, NULL
, 0 },
697 { OPT_LEVELS_NONE
, 0, NULL
, 0 }
700 /* Default the options in OPTS and OPTS_SET based on the optimization
701 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
703 default_options_optimization (struct gcc_options
*opts
,
704 struct gcc_options
*opts_set
,
705 struct cl_decoded_option
*decoded_options
,
706 unsigned int decoded_options_count
,
708 unsigned int lang_mask
,
709 const struct cl_option_handlers
*handlers
,
710 diagnostic_context
*dc
)
714 bool openacc_mode
= false;
716 /* Scan to see what optimization level has been specified. That will
717 determine the default value of many flags. */
718 for (i
= 1; i
< decoded_options_count
; i
++)
720 struct cl_decoded_option
*opt
= &decoded_options
[i
];
721 switch (opt
->opt_index
)
724 if (*opt
->arg
== '\0')
726 opts
->x_optimize
= 1;
727 opts
->x_optimize_size
= 0;
728 opts
->x_optimize_fast
= 0;
729 opts
->x_optimize_debug
= 0;
733 const int optimize_val
= integral_argument (opt
->arg
);
734 if (optimize_val
== -1)
735 error_at (loc
, "argument to %<-O%> should be a non-negative "
736 "integer, %<g%>, %<s%>, %<z%> or %<fast%>");
739 opts
->x_optimize
= optimize_val
;
740 if ((unsigned int) opts
->x_optimize
> 255)
741 opts
->x_optimize
= 255;
742 opts
->x_optimize_size
= 0;
743 opts
->x_optimize_fast
= 0;
744 opts
->x_optimize_debug
= 0;
750 opts
->x_optimize_size
= 1;
752 /* Optimizing for size forces optimize to be 2. */
753 opts
->x_optimize
= 2;
754 opts
->x_optimize_fast
= 0;
755 opts
->x_optimize_debug
= 0;
759 opts
->x_optimize_size
= 2;
761 /* Optimizing for size forces optimize to be 2. */
762 opts
->x_optimize
= 2;
763 opts
->x_optimize_fast
= 0;
764 opts
->x_optimize_debug
= 0;
768 /* -Ofast only adds flags to -O3. */
769 opts
->x_optimize_size
= 0;
770 opts
->x_optimize
= 3;
771 opts
->x_optimize_fast
= 1;
772 opts
->x_optimize_debug
= 0;
776 /* -Og selects optimization level 1. */
777 opts
->x_optimize_size
= 0;
778 opts
->x_optimize
= 1;
779 opts
->x_optimize_fast
= 0;
780 opts
->x_optimize_debug
= 1;
789 /* Ignore other options in this prescan. */
794 maybe_default_options (opts
, opts_set
, default_options_table
,
795 opts
->x_optimize
, opts
->x_optimize_size
,
796 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
797 lang_mask
, handlers
, loc
, dc
);
799 /* -O2 param settings. */
800 opt2
= (opts
->x_optimize
>= 2);
803 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_pta
, true);
805 /* Track fields in field-sensitive alias analysis. */
807 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_fields_for_field_sensitive
,
810 if (opts
->x_optimize_size
)
811 /* We want to crossjump as much as possible. */
812 SET_OPTION_IF_UNSET (opts
, opts_set
, param_min_crossjump_insns
, 1);
814 /* Restrict the amount of work combine does at -Og while retaining
815 most of its useful transforms. */
816 if (opts
->x_optimize_debug
)
817 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_combine_insns
, 2);
819 /* Allow default optimizations to be specified on a per-machine basis. */
820 maybe_default_options (opts
, opts_set
,
821 targetm_common
.option_optimization_table
,
822 opts
->x_optimize
, opts
->x_optimize_size
,
823 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
824 lang_mask
, handlers
, loc
, dc
);
827 /* Control IPA optimizations based on different live patching LEVEL. */
829 control_options_for_live_patching (struct gcc_options
*opts
,
830 struct gcc_options
*opts_set
,
831 enum live_patching_level level
,
834 gcc_assert (level
> LIVE_PATCHING_NONE
);
838 case LIVE_PATCHING_INLINE_ONLY_STATIC
:
839 #define LIVE_PATCHING_OPTION "-flive-patching=inline-only-static"
840 if (opts_set
->x_flag_ipa_cp_clone
&& opts
->x_flag_ipa_cp_clone
)
841 error_at (loc
, "%qs is incompatible with %qs",
842 "-fipa-cp-clone", LIVE_PATCHING_OPTION
);
844 opts
->x_flag_ipa_cp_clone
= 0;
846 if (opts_set
->x_flag_ipa_sra
&& opts
->x_flag_ipa_sra
)
847 error_at (loc
, "%qs is incompatible with %qs",
848 "-fipa-sra", LIVE_PATCHING_OPTION
);
850 opts
->x_flag_ipa_sra
= 0;
852 if (opts_set
->x_flag_partial_inlining
&& opts
->x_flag_partial_inlining
)
853 error_at (loc
, "%qs is incompatible with %qs",
854 "-fpartial-inlining", LIVE_PATCHING_OPTION
);
856 opts
->x_flag_partial_inlining
= 0;
858 if (opts_set
->x_flag_ipa_cp
&& opts
->x_flag_ipa_cp
)
859 error_at (loc
, "%qs is incompatible with %qs",
860 "-fipa-cp", LIVE_PATCHING_OPTION
);
862 opts
->x_flag_ipa_cp
= 0;
865 case LIVE_PATCHING_INLINE_CLONE
:
866 #undef LIVE_PATCHING_OPTION
867 #define LIVE_PATCHING_OPTION "-flive-patching=inline-only-static|inline-clone"
868 /* live patching should disable whole-program optimization. */
869 if (opts_set
->x_flag_whole_program
&& opts
->x_flag_whole_program
)
870 error_at (loc
, "%qs is incompatible with %qs",
871 "-fwhole-program", LIVE_PATCHING_OPTION
);
873 opts
->x_flag_whole_program
= 0;
875 /* visibility change should be excluded by !flag_whole_program
876 && !in_lto_p && !flag_ipa_cp_clone && !flag_ipa_sra
877 && !flag_partial_inlining. */
879 if (opts_set
->x_flag_ipa_pta
&& opts
->x_flag_ipa_pta
)
880 error_at (loc
, "%qs is incompatible with %qs",
881 "-fipa-pta", LIVE_PATCHING_OPTION
);
883 opts
->x_flag_ipa_pta
= 0;
885 if (opts_set
->x_flag_ipa_reference
&& opts
->x_flag_ipa_reference
)
886 error_at (loc
, "%qs is incompatible with %qs",
887 "-fipa-reference", LIVE_PATCHING_OPTION
);
889 opts
->x_flag_ipa_reference
= 0;
891 if (opts_set
->x_flag_ipa_ra
&& opts
->x_flag_ipa_ra
)
892 error_at (loc
, "%qs is incompatible with %qs",
893 "-fipa-ra", LIVE_PATCHING_OPTION
);
895 opts
->x_flag_ipa_ra
= 0;
897 if (opts_set
->x_flag_ipa_icf
&& opts
->x_flag_ipa_icf
)
898 error_at (loc
, "%qs is incompatible with %qs",
899 "-fipa-icf", LIVE_PATCHING_OPTION
);
901 opts
->x_flag_ipa_icf
= 0;
903 if (opts_set
->x_flag_ipa_icf_functions
&& opts
->x_flag_ipa_icf_functions
)
904 error_at (loc
, "%qs is incompatible with %qs",
905 "-fipa-icf-functions", LIVE_PATCHING_OPTION
);
907 opts
->x_flag_ipa_icf_functions
= 0;
909 if (opts_set
->x_flag_ipa_icf_variables
&& opts
->x_flag_ipa_icf_variables
)
910 error_at (loc
, "%qs is incompatible with %qs",
911 "-fipa-icf-variables", LIVE_PATCHING_OPTION
);
913 opts
->x_flag_ipa_icf_variables
= 0;
915 if (opts_set
->x_flag_ipa_bit_cp
&& opts
->x_flag_ipa_bit_cp
)
916 error_at (loc
, "%qs is incompatible with %qs",
917 "-fipa-bit-cp", LIVE_PATCHING_OPTION
);
919 opts
->x_flag_ipa_bit_cp
= 0;
921 if (opts_set
->x_flag_ipa_vrp
&& opts
->x_flag_ipa_vrp
)
922 error_at (loc
, "%qs is incompatible with %qs",
923 "-fipa-vrp", LIVE_PATCHING_OPTION
);
925 opts
->x_flag_ipa_vrp
= 0;
927 if (opts_set
->x_flag_ipa_pure_const
&& opts
->x_flag_ipa_pure_const
)
928 error_at (loc
, "%qs is incompatible with %qs",
929 "-fipa-pure-const", LIVE_PATCHING_OPTION
);
931 opts
->x_flag_ipa_pure_const
= 0;
933 if (opts_set
->x_flag_ipa_modref
&& opts
->x_flag_ipa_modref
)
935 "%<-fipa-modref%> is incompatible with %qs",
936 LIVE_PATCHING_OPTION
);
938 opts
->x_flag_ipa_modref
= 0;
940 /* FIXME: disable unreachable code removal. */
942 /* discovery of functions/variables with no address taken. */
943 if (opts_set
->x_flag_ipa_reference_addressable
944 && opts
->x_flag_ipa_reference_addressable
)
945 error_at (loc
, "%qs is incompatible with %qs",
946 "-fipa-reference-addressable", LIVE_PATCHING_OPTION
);
948 opts
->x_flag_ipa_reference_addressable
= 0;
950 /* ipa stack alignment propagation. */
951 if (opts_set
->x_flag_ipa_stack_alignment
952 && opts
->x_flag_ipa_stack_alignment
)
953 error_at (loc
, "%qs is incompatible with %qs",
954 "-fipa-stack-alignment", LIVE_PATCHING_OPTION
);
956 opts
->x_flag_ipa_stack_alignment
= 0;
962 #undef LIVE_PATCHING_OPTION
965 /* --help option argument if set. */
966 vec
<const char *> help_option_arguments
;
968 /* Return the string name describing a sanitizer argument which has been
969 provided on the command line and has set this particular flag. */
971 find_sanitizer_argument (struct gcc_options
*opts
, unsigned int flags
)
973 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
975 /* Need to find the sanitizer_opts element which:
976 a) Could have set the flags requested.
977 b) Has been set on the command line.
979 Can have (a) without (b) if the flag requested is e.g.
980 SANITIZE_ADDRESS, since both -fsanitize=address and
981 -fsanitize=kernel-address set this flag.
983 Can have (b) without (a) by requesting more than one sanitizer on the
985 if ((sanitizer_opts
[i
].flag
& opts
->x_flag_sanitize
)
986 != sanitizer_opts
[i
].flag
)
988 if ((sanitizer_opts
[i
].flag
& flags
) != flags
)
990 return sanitizer_opts
[i
].name
;
996 /* Report an error to the user about sanitizer options they have requested
997 which have set conflicting flags.
999 LEFT and RIGHT indicate sanitizer flags which conflict with each other, this
1000 function reports an error if both have been set in OPTS->x_flag_sanitize and
1001 ensures the error identifies the requested command line options that have
1004 report_conflicting_sanitizer_options (struct gcc_options
*opts
, location_t loc
,
1005 unsigned int left
, unsigned int right
)
1007 unsigned int left_seen
= (opts
->x_flag_sanitize
& left
);
1008 unsigned int right_seen
= (opts
->x_flag_sanitize
& right
);
1009 if (left_seen
&& right_seen
)
1011 const char* left_arg
= find_sanitizer_argument (opts
, left_seen
);
1012 const char* right_arg
= find_sanitizer_argument (opts
, right_seen
);
1013 gcc_assert (left_arg
&& right_arg
);
1015 "%<-fsanitize=%s%> is incompatible with %<-fsanitize=%s%>",
1016 left_arg
, right_arg
);
1020 /* After all options at LOC have been read into OPTS and OPTS_SET,
1021 finalize settings of those options and diagnose incompatible
1024 finish_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
1027 if (opts
->x_dump_base_name
1028 && ! opts
->x_dump_base_name_prefixed
)
1030 const char *sep
= opts
->x_dump_base_name
;
1033 if (IS_DIR_SEPARATOR (*sep
))
1037 /* If dump_base_path contains subdirectories, don't prepend
1039 else if (opts
->x_dump_dir_name
)
1040 /* We have a DUMP_DIR_NAME, prepend that. */
1041 opts
->x_dump_base_name
= opts_concat (opts
->x_dump_dir_name
,
1042 opts
->x_dump_base_name
, NULL
);
1044 /* It is definitely prefixed now. */
1045 opts
->x_dump_base_name_prefixed
= true;
1048 /* Handle related options for unit-at-a-time, toplevel-reorder, and
1050 if (!opts
->x_flag_unit_at_a_time
)
1052 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
1053 error_at (loc
, "section anchors must be disabled when unit-at-a-time "
1055 opts
->x_flag_section_anchors
= 0;
1056 if (opts
->x_flag_toplevel_reorder
== 1)
1057 error_at (loc
, "toplevel reorder must be disabled when unit-at-a-time "
1059 opts
->x_flag_toplevel_reorder
= 0;
1062 /* -fself-test depends on the state of the compiler prior to
1063 compiling anything. Ideally it should be run on an empty source
1064 file. However, in case we get run with actual source, assume
1065 -fsyntax-only which will inhibit any compiler initialization
1066 which may confuse the self tests. */
1067 if (opts
->x_flag_self_test
)
1068 opts
->x_flag_syntax_only
= 1;
1070 if (opts
->x_flag_tm
&& opts
->x_flag_non_call_exceptions
)
1071 sorry ("transactional memory is not supported with non-call exceptions");
1073 /* Unless the user has asked for section anchors, we disable toplevel
1074 reordering at -O0 to disable transformations that might be surprising
1075 to end users and to get -fno-toplevel-reorder tested. */
1076 if (!opts
->x_optimize
1077 && opts
->x_flag_toplevel_reorder
== 2
1078 && !(opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
))
1080 opts
->x_flag_toplevel_reorder
= 0;
1081 opts
->x_flag_section_anchors
= 0;
1083 if (!opts
->x_flag_toplevel_reorder
)
1085 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
1086 error_at (loc
, "section anchors must be disabled when toplevel reorder"
1088 opts
->x_flag_section_anchors
= 0;
1091 if (!opts
->x_flag_opts_finished
)
1093 /* We initialize opts->x_flag_pie to -1 so that targets can set a
1095 if (opts
->x_flag_pie
== -1)
1097 /* We initialize opts->x_flag_pic to -1 so that we can tell if
1098 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
1099 if (opts
->x_flag_pic
== -1)
1100 opts
->x_flag_pie
= DEFAULT_FLAG_PIE
;
1102 opts
->x_flag_pie
= 0;
1104 /* If -fPIE or -fpie is used, turn on PIC. */
1105 if (opts
->x_flag_pie
)
1106 opts
->x_flag_pic
= opts
->x_flag_pie
;
1107 else if (opts
->x_flag_pic
== -1)
1108 opts
->x_flag_pic
= 0;
1109 if (opts
->x_flag_pic
&& !opts
->x_flag_pie
)
1110 opts
->x_flag_shlib
= 1;
1111 opts
->x_flag_opts_finished
= true;
1114 /* We initialize opts->x_flag_stack_protect to -1 so that targets
1115 can set a default value. */
1116 if (opts
->x_flag_stack_protect
== -1)
1117 opts
->x_flag_stack_protect
= DEFAULT_FLAG_SSP
;
1119 if (opts
->x_optimize
== 0)
1121 /* Inlining does not work if not optimizing,
1122 so force it not to be done. */
1123 opts
->x_warn_inline
= 0;
1124 opts
->x_flag_no_inline
= 1;
1127 /* At -O0 or -Og, turn __builtin_unreachable into a trap. */
1128 if (!opts
->x_optimize
|| opts
->x_optimize_debug
)
1129 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unreachable_traps
, true);
1131 /* Pipelining of outer loops is only possible when general pipelining
1132 capabilities are requested. */
1133 if (!opts
->x_flag_sel_sched_pipelining
)
1134 opts
->x_flag_sel_sched_pipelining_outer_loops
= 0;
1136 if (opts
->x_flag_conserve_stack
)
1138 SET_OPTION_IF_UNSET (opts
, opts_set
, param_large_stack_frame
, 100);
1139 SET_OPTION_IF_UNSET (opts
, opts_set
, param_stack_frame_growth
, 40);
1142 if (opts
->x_flag_lto
)
1145 opts
->x_flag_generate_lto
= 1;
1147 /* When generating IL, do not operate in whole-program mode.
1148 Otherwise, symbols will be privatized too early, causing link
1150 opts
->x_flag_whole_program
= 0;
1152 error_at (loc
, "LTO support has not been enabled in this configuration");
1154 if (!opts
->x_flag_fat_lto_objects
1155 && (!HAVE_LTO_PLUGIN
1156 || (opts_set
->x_flag_use_linker_plugin
1157 && !opts
->x_flag_use_linker_plugin
)))
1159 if (opts_set
->x_flag_fat_lto_objects
)
1160 error_at (loc
, "%<-fno-fat-lto-objects%> are supported only with "
1162 opts
->x_flag_fat_lto_objects
= 1;
1165 /* -gsplit-dwarf isn't compatible with LTO, see PR88389. */
1166 if (opts
->x_dwarf_split_debug_info
)
1168 inform (loc
, "%<-gsplit-dwarf%> is not supported with LTO,"
1170 opts
->x_dwarf_split_debug_info
= 0;
1174 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
1175 default value if they choose based on other options. */
1176 if (opts
->x_flag_split_stack
== -1)
1177 opts
->x_flag_split_stack
= 0;
1178 else if (opts
->x_flag_split_stack
)
1180 if (!targetm_common
.supports_split_stack (true, opts
))
1182 error_at (loc
, "%<-fsplit-stack%> is not supported by "
1183 "this compiler configuration");
1184 opts
->x_flag_split_stack
= 0;
1188 /* If stack splitting is turned on, and the user did not explicitly
1189 request function partitioning, turn off partitioning, as it
1190 confuses the linker when trying to handle partitioned split-stack
1191 code that calls a non-split-stack functions. But if partitioning
1192 was turned on explicitly just hope for the best. */
1193 if (opts
->x_flag_split_stack
1194 && opts
->x_flag_reorder_blocks_and_partition
)
1195 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_reorder_blocks_and_partition
, 0);
1197 if (opts
->x_flag_reorder_blocks_and_partition
)
1198 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_reorder_functions
, 1);
1200 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
1201 if (opts
->x_dwarf_split_debug_info
)
1202 opts
->x_debug_generate_pub_sections
= 2;
1204 if ((opts
->x_flag_sanitize
1205 & (SANITIZE_USER_ADDRESS
| SANITIZE_KERNEL_ADDRESS
)) == 0)
1207 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_COMPARE
)
1209 "%<-fsanitize=pointer-compare%> must be combined with "
1210 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1211 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_SUBTRACT
)
1213 "%<-fsanitize=pointer-subtract%> must be combined with "
1214 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1217 /* Address sanitizers conflict with the thread sanitizer. */
1218 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_THREAD
,
1220 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_THREAD
,
1221 SANITIZE_HWADDRESS
);
1222 /* The leak sanitizer conflicts with the thread sanitizer. */
1223 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_LEAK
,
1226 /* No combination of HWASAN and ASAN work together. */
1227 report_conflicting_sanitizer_options (opts
, loc
,
1228 SANITIZE_HWADDRESS
, SANITIZE_ADDRESS
);
1230 /* The userspace and kernel address sanitizers conflict with each other. */
1231 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_USER_HWADDRESS
,
1232 SANITIZE_KERNEL_HWADDRESS
);
1233 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_USER_ADDRESS
,
1234 SANITIZE_KERNEL_ADDRESS
);
1236 /* Check error recovery for -fsanitize-recover option. */
1237 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1238 if ((opts
->x_flag_sanitize_recover
& sanitizer_opts
[i
].flag
)
1239 && !sanitizer_opts
[i
].can_recover
)
1240 error_at (loc
, "%<-fsanitize-recover=%s%> is not supported",
1241 sanitizer_opts
[i
].name
);
1243 /* Check -fsanitize-trap option. */
1244 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1245 if ((opts
->x_flag_sanitize_trap
& sanitizer_opts
[i
].flag
)
1246 && !sanitizer_opts
[i
].can_trap
1247 /* Allow -fsanitize-trap=all or -fsanitize-trap=undefined
1248 to set flag_sanitize_trap & SANITIZE_VPTR bit which will
1249 effectively disable -fsanitize=vptr, just disallow
1250 explicit -fsanitize-trap=vptr. */
1251 && sanitizer_opts
[i
].flag
!= SANITIZE_VPTR
)
1252 error_at (loc
, "%<-fsanitize-trap=%s%> is not supported",
1253 sanitizer_opts
[i
].name
);
1255 /* When instrumenting the pointers, we don't want to remove
1256 the null pointer checks. */
1257 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
1258 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
1259 opts
->x_flag_delete_null_pointer_checks
= 0;
1261 /* Aggressive compiler optimizations may cause false negatives. */
1262 if (opts
->x_flag_sanitize
& ~(SANITIZE_LEAK
| SANITIZE_UNREACHABLE
))
1263 opts
->x_flag_aggressive_loop_optimizations
= 0;
1265 /* Enable -fsanitize-address-use-after-scope if either address sanitizer is
1267 if (opts
->x_flag_sanitize
1268 & (SANITIZE_USER_ADDRESS
| SANITIZE_USER_HWADDRESS
))
1269 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_sanitize_address_use_after_scope
,
1272 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1274 if (opts
->x_flag_sanitize_address_use_after_scope
)
1276 if (opts
->x_flag_stack_reuse
!= SR_NONE
1277 && opts_set
->x_flag_stack_reuse
!= SR_NONE
)
1279 "%<-fsanitize-address-use-after-scope%> requires "
1280 "%<-fstack-reuse=none%> option");
1282 opts
->x_flag_stack_reuse
= SR_NONE
;
1285 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
) && opts
->x_flag_tm
)
1286 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1288 if ((opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) && opts
->x_flag_tm
)
1289 sorry ("transactional memory is not supported with "
1290 "%<-fsanitize=kernel-address%>");
1292 /* Currently live patching is not support for LTO. */
1293 if (opts
->x_flag_live_patching
== LIVE_PATCHING_INLINE_ONLY_STATIC
&& opts
->x_flag_lto
)
1294 sorry ("live patching (with %qs) is not supported with LTO",
1295 "inline-only-static");
1297 /* Currently vtable verification is not supported for LTO */
1298 if (opts
->x_flag_vtable_verify
&& opts
->x_flag_lto
)
1299 sorry ("vtable verification is not supported with LTO");
1301 /* Control IPA optimizations based on different -flive-patching level. */
1302 if (opts
->x_flag_live_patching
)
1303 control_options_for_live_patching (opts
, opts_set
,
1304 opts
->x_flag_live_patching
,
1307 /* Allow cunroll to grow size accordingly. */
1308 if (!opts_set
->x_flag_cunroll_grow_size
)
1309 opts
->x_flag_cunroll_grow_size
1310 = (opts
->x_flag_unroll_loops
1311 || opts
->x_flag_peel_loops
1312 || opts
->x_optimize
>= 3);
1314 /* With -fcx-limited-range, we do cheap and quick complex arithmetic. */
1315 if (opts
->x_flag_cx_limited_range
)
1316 opts
->x_flag_complex_method
= 0;
1317 else if (opts_set
->x_flag_cx_limited_range
)
1318 opts
->x_flag_complex_method
= opts
->x_flag_default_complex_method
;
1320 /* With -fcx-fortran-rules, we do something in-between cheap and C99. */
1321 if (opts
->x_flag_cx_fortran_rules
)
1322 opts
->x_flag_complex_method
= 1;
1323 else if (opts_set
->x_flag_cx_fortran_rules
)
1324 opts
->x_flag_complex_method
= opts
->x_flag_default_complex_method
;
1326 /* Use -fvect-cost-model=cheap instead of -fvect-cost-mode=very-cheap
1327 by default with explicit -ftree-{loop,slp}-vectorize. */
1328 if (opts
->x_optimize
== 2
1329 && (opts_set
->x_flag_tree_loop_vectorize
1330 || opts_set
->x_flag_tree_vectorize
))
1331 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_vect_cost_model
,
1332 VECT_COST_MODEL_CHEAP
);
1334 if (opts
->x_flag_gtoggle
)
1336 /* Make sure to process -gtoggle only once. */
1337 opts
->x_flag_gtoggle
= false;
1338 if (opts
->x_debug_info_level
== DINFO_LEVEL_NONE
)
1340 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
1342 if (opts
->x_write_symbols
== NO_DEBUG
)
1343 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
1346 opts
->x_debug_info_level
= DINFO_LEVEL_NONE
;
1349 if (!opts_set
->x_debug_nonbind_markers_p
)
1350 opts
->x_debug_nonbind_markers_p
1352 && opts
->x_debug_info_level
>= DINFO_LEVEL_NORMAL
1353 && dwarf_debuginfo_p (opts
)
1354 && !(opts
->x_flag_selective_scheduling
1355 || opts
->x_flag_selective_scheduling2
));
1357 /* We know which debug output will be used so we can set flag_var_tracking
1358 and flag_var_tracking_uninit if the user has not specified them. */
1359 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
1360 || !dwarf_debuginfo_p (opts
)
1361 /* We have not yet initialized debug hooks so match that to check
1362 whether we're only doing DWARF2_LINENO_DEBUGGING_INFO. */
1363 #ifndef DWARF2_DEBUGGING_INFO
1368 if ((opts_set
->x_flag_var_tracking
&& opts
->x_flag_var_tracking
== 1)
1369 || (opts_set
->x_flag_var_tracking_uninit
1370 && opts
->x_flag_var_tracking_uninit
== 1))
1372 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
1373 warning_at (UNKNOWN_LOCATION
, 0,
1374 "variable tracking requested, but useless unless "
1375 "producing debug info");
1377 warning_at (UNKNOWN_LOCATION
, 0,
1378 "variable tracking requested, but not supported "
1379 "by this debug format");
1381 opts
->x_flag_var_tracking
= 0;
1382 opts
->x_flag_var_tracking_uninit
= 0;
1385 /* One could use EnabledBy, but it would lead to a circular dependency. */
1386 if (!opts_set
->x_flag_var_tracking_uninit
)
1387 opts
->x_flag_var_tracking_uninit
= opts
->x_flag_var_tracking
;
1389 if (!opts_set
->x_flag_var_tracking_assignments
)
1390 opts
->x_flag_var_tracking_assignments
1391 = (opts
->x_flag_var_tracking
1392 && !(opts
->x_flag_selective_scheduling
1393 || opts
->x_flag_selective_scheduling2
));
1395 if (opts
->x_flag_var_tracking_assignments_toggle
)
1396 opts
->x_flag_var_tracking_assignments
1397 = !opts
->x_flag_var_tracking_assignments
;
1399 if (opts
->x_flag_var_tracking_assignments
&& !opts
->x_flag_var_tracking
)
1400 opts
->x_flag_var_tracking
= opts
->x_flag_var_tracking_assignments
= -1;
1402 if (opts
->x_flag_var_tracking_assignments
1403 && (opts
->x_flag_selective_scheduling
1404 || opts
->x_flag_selective_scheduling2
))
1406 "var-tracking-assignments changes selective scheduling");
1408 if (opts
->x_flag_syntax_only
)
1410 opts
->x_write_symbols
= NO_DEBUG
;
1411 opts
->x_profile_flag
= 0;
1414 if (opts
->x_warn_strict_flex_arrays
)
1415 if (opts
->x_flag_strict_flex_arrays
== 0)
1417 opts
->x_warn_strict_flex_arrays
= 0;
1418 warning_at (UNKNOWN_LOCATION
, 0,
1419 "%<-Wstrict-flex-arrays%> is ignored when"
1420 " %<-fstrict-flex-arrays%> is not present");
1423 diagnose_options (opts
, opts_set
, loc
);
1426 /* The function diagnoses incompatible combinations for provided options
1427 (OPTS and OPTS_SET) at a given LOCation. The function is called both
1428 when command line is parsed (after the target optimization hook) and
1429 when an optimize/target attribute (or pragma) is used. */
1431 void diagnose_options (gcc_options
*opts
, gcc_options
*opts_set
,
1434 /* The optimization to partition hot and cold basic blocks into separate
1435 sections of the .o and executable files does not work (currently)
1436 with exception handling. This is because there is no support for
1437 generating unwind info. If opts->x_flag_exceptions is turned on
1438 we need to turn off the partitioning optimization. */
1440 enum unwind_info_type ui_except
1441 = targetm_common
.except_unwind_info (opts
);
1443 if (opts
->x_flag_exceptions
1444 && opts
->x_flag_reorder_blocks_and_partition
1445 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1447 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1449 "%<-freorder-blocks-and-partition%> does not work "
1450 "with exceptions on this architecture");
1451 opts
->x_flag_reorder_blocks_and_partition
= 0;
1452 opts
->x_flag_reorder_blocks
= 1;
1455 /* If user requested unwind info, then turn off the partitioning
1458 if (opts
->x_flag_unwind_tables
1459 && !targetm_common
.unwind_tables_default
1460 && opts
->x_flag_reorder_blocks_and_partition
1461 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1463 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1465 "%<-freorder-blocks-and-partition%> does not support "
1466 "unwind info on this architecture");
1467 opts
->x_flag_reorder_blocks_and_partition
= 0;
1468 opts
->x_flag_reorder_blocks
= 1;
1471 /* If the target requested unwind info, then turn off the partitioning
1472 optimization with a different message. Likewise, if the target does not
1473 support named sections. */
1475 if (opts
->x_flag_reorder_blocks_and_partition
1476 && (!targetm_common
.have_named_sections
1477 || (opts
->x_flag_unwind_tables
1478 && targetm_common
.unwind_tables_default
1479 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
1481 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1483 "%<-freorder-blocks-and-partition%> does not work "
1484 "on this architecture");
1485 opts
->x_flag_reorder_blocks_and_partition
= 0;
1486 opts
->x_flag_reorder_blocks
= 1;
1492 #define LEFT_COLUMN 27
1494 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1495 followed by word-wrapped HELP in a second column. */
1497 wrap_help (const char *help
,
1499 unsigned int item_width
,
1500 unsigned int columns
)
1502 unsigned int col_width
= LEFT_COLUMN
;
1503 unsigned int remaining
, room
, len
;
1505 remaining
= strlen (help
);
1509 room
= columns
- 3 - MAX (col_width
, item_width
);
1518 for (i
= 0; help
[i
]; i
++)
1520 if (i
>= room
&& len
!= remaining
)
1524 else if ((help
[i
] == '-' || help
[i
] == '/')
1525 && help
[i
+ 1] != ' '
1526 && i
> 0 && ISALPHA (help
[i
- 1]))
1531 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1533 while (help
[len
] == ' ')
1541 /* Data structure used to print list of valid option values. */
1543 class option_help_tuple
1546 option_help_tuple (int code
, vec
<const char *> values
):
1547 m_code (code
), m_values (values
)
1550 /* Code of an option. */
1553 /* List of possible values. */
1554 vec
<const char *> m_values
;
1557 /* Print help for a specific front-end, etc. */
1559 print_filtered_help (unsigned int include_flags
,
1560 unsigned int exclude_flags
,
1561 unsigned int any_flags
,
1562 unsigned int columns
,
1563 struct gcc_options
*opts
,
1564 unsigned int lang_mask
)
1569 bool displayed
= false;
1572 if (!opts
->x_help_printed
)
1573 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1575 if (!opts
->x_help_enum_printed
)
1576 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1578 auto_vec
<option_help_tuple
> help_tuples
;
1580 for (i
= 0; i
< cl_options_count
; i
++)
1582 const struct cl_option
*option
= cl_options
+ i
;
1587 if (include_flags
== 0
1588 || ((option
->flags
& include_flags
) != include_flags
))
1590 if ((option
->flags
& any_flags
) == 0)
1594 /* Skip unwanted switches. */
1595 if ((option
->flags
& exclude_flags
) != 0)
1598 /* The driver currently prints its own help text. */
1599 if ((option
->flags
& CL_DRIVER
) != 0
1600 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1601 | CL_COMMON
| CL_TARGET
)) == 0)
1604 /* If an option contains a language specification,
1605 exclude it from common unless all languages are present. */
1606 if ((include_flags
& CL_COMMON
)
1607 && !(option
->flags
& CL_DRIVER
)
1608 && (option
->flags
& CL_LANG_ALL
)
1609 && (option
->flags
& CL_LANG_ALL
) != CL_LANG_ALL
)
1613 /* Skip switches that have already been printed. */
1614 if (opts
->x_help_printed
[i
])
1617 opts
->x_help_printed
[i
] = true;
1619 help
= option
->help
;
1622 if (exclude_flags
& CL_UNDOCUMENTED
)
1625 help
= undocumented_msg
;
1628 /* Get the translation. */
1631 if (option
->alias_target
< N_OPTS
1632 && cl_options
[option
->alias_target
].help
)
1634 const struct cl_option
*target
= cl_options
+ option
->alias_target
;
1635 if (option
->help
== NULL
)
1637 /* The option is undocumented but is an alias for an option that
1638 is documented. If the option has alias arguments, then its
1639 purpose is to provide certain arguments to the other option, so
1640 inform the reader of this. Otherwise, point the reader to the
1641 other option in preference to the former. */
1643 if (option
->alias_arg
)
1645 if (option
->neg_alias_arg
)
1646 snprintf (new_help
, sizeof new_help
,
1647 _("Same as %s%s (or, in negated form, %s%s)."),
1648 target
->opt_text
, option
->alias_arg
,
1649 target
->opt_text
, option
->neg_alias_arg
);
1651 snprintf (new_help
, sizeof new_help
,
1653 target
->opt_text
, option
->alias_arg
);
1656 snprintf (new_help
, sizeof new_help
,
1662 /* For documented options with aliases, mention the aliased
1663 option's name for reference. */
1664 snprintf (new_help
, sizeof new_help
,
1665 _("%s Same as %s."),
1666 help
, cl_options
[option
->alias_target
].opt_text
);
1672 if (option
->warn_message
)
1674 /* Mention that the use of the option will trigger a warning. */
1675 if (help
== new_help
)
1676 snprintf (new_help
+ strlen (new_help
),
1677 sizeof new_help
- strlen (new_help
),
1678 " %s", _(use_diagnosed_msg
));
1680 snprintf (new_help
, sizeof new_help
,
1681 "%s %s", help
, _(use_diagnosed_msg
));
1686 /* Find the gap between the name of the
1687 option and its descriptive text. */
1688 tab
= strchr (help
, '\t');
1697 opt
= option
->opt_text
;
1701 /* With the -Q option enabled we change the descriptive text associated
1702 with an option to be an indication of its current setting. */
1703 if (!opts
->x_quiet_flag
)
1705 void *flag_var
= option_flag_var (i
, opts
);
1707 if (len
< (LEFT_COLUMN
+ 2))
1708 strcpy (new_help
, "\t\t");
1710 strcpy (new_help
, "\t");
1712 /* Set to print whether the option is enabled or disabled,
1713 or, if it's an alias for another option, the name of
1714 the aliased option. */
1715 bool print_state
= false;
1717 if (flag_var
!= NULL
1718 && option
->var_type
!= CLVC_DEFER
)
1720 /* If OPTION is only available for a specific subset
1721 of languages other than this one, mention them. */
1722 bool avail_for_lang
= true;
1723 if (unsigned langset
= option
->flags
& CL_LANG_ALL
)
1725 if (!(langset
& lang_mask
))
1727 avail_for_lang
= false;
1728 strcat (new_help
, _("[available in "));
1729 for (unsigned i
= 0, n
= 0; (1U << i
) < CL_LANG_ALL
; ++i
)
1730 if (langset
& (1U << i
))
1733 strcat (new_help
, ", ");
1734 strcat (new_help
, lang_names
[i
]);
1736 strcat (new_help
, "]");
1739 if (!avail_for_lang
)
1740 ; /* Print nothing else if the option is not available
1741 in the current language. */
1742 else if (option
->flags
& CL_JOINED
)
1744 if (option
->var_type
== CLVC_STRING
)
1746 if (* (const char **) flag_var
!= NULL
)
1747 snprintf (new_help
+ strlen (new_help
),
1748 sizeof (new_help
) - strlen (new_help
),
1749 "%s", * (const char **) flag_var
);
1751 else if (option
->var_type
== CLVC_ENUM
)
1753 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1755 const char *arg
= NULL
;
1757 value
= e
->get (flag_var
);
1758 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1760 arg
= _("[default]");
1761 snprintf (new_help
+ strlen (new_help
),
1762 sizeof (new_help
) - strlen (new_help
),
1767 if (option
->cl_host_wide_int
)
1768 sprintf (new_help
+ strlen (new_help
),
1769 _("%llu bytes"), (unsigned long long)
1770 *(unsigned HOST_WIDE_INT
*) flag_var
);
1772 sprintf (new_help
+ strlen (new_help
),
1773 "%i", * (int *) flag_var
);
1780 /* When there is no argument, print the option state only
1781 if the option takes no argument. */
1782 print_state
= !(option
->flags
& CL_JOINED
);
1786 if (option
->alias_target
< N_OPTS
1787 && option
->alias_target
!= OPT_SPECIAL_warn_removed
1788 && option
->alias_target
!= OPT_SPECIAL_ignore
1789 && option
->alias_target
!= OPT_SPECIAL_input_file
1790 && option
->alias_target
!= OPT_SPECIAL_program_name
1791 && option
->alias_target
!= OPT_SPECIAL_unknown
)
1793 const struct cl_option
*target
1794 = &cl_options
[option
->alias_target
];
1795 sprintf (new_help
+ strlen (new_help
), "%s%s",
1797 option
->alias_arg
? option
->alias_arg
: "");
1799 else if (option
->alias_target
== OPT_SPECIAL_ignore
)
1800 strcat (new_help
, ("[ignored]"));
1803 /* Print the state for an on/off option. */
1804 int ena
= option_enabled (i
, lang_mask
, opts
);
1806 strcat (new_help
, _("[enabled]"));
1808 strcat (new_help
, _("[disabled]"));
1815 if (option
->range_max
!= -1 && tab
== NULL
)
1818 snprintf (b
, sizeof (b
), "<%d,%d>", option
->range_min
,
1820 opt
= concat (opt
, b
, NULL
);
1824 wrap_help (help
, opt
, len
, columns
);
1827 if (option
->var_type
== CLVC_ENUM
1828 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1829 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1832 vec
<const char *> option_values
1833 = targetm_common
.get_valid_option_values (i
, NULL
);
1834 if (!option_values
.is_empty ())
1835 help_tuples
.safe_push (option_help_tuple (i
, option_values
));
1841 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1844 printf (_(" No options with the desired characteristics were found\n"));
1849 /* PR 31349: Tell the user how to see all of the
1850 options supported by a specific front end. */
1851 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1852 if ((1U << i
) & langs
)
1853 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1854 lang_names
[i
], lang_names
[i
]);
1858 else if (! displayed
)
1859 printf (_(" All options with the desired characteristics have already been displayed\n"));
1863 /* Print details of enumerated option arguments, if those
1864 enumerations have help text headings provided. If no help text
1865 is provided, presume that the possible values are listed in the
1866 help text for the relevant options. */
1867 for (i
= 0; i
< cl_enums_count
; i
++)
1869 unsigned int j
, pos
;
1871 if (opts
->x_help_enum_printed
[i
] != 1)
1873 if (cl_enums
[i
].help
== NULL
)
1875 printf (" %s\n ", _(cl_enums
[i
].help
));
1877 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1879 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1881 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1883 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1893 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1898 opts
->x_help_enum_printed
[i
] = 2;
1901 for (unsigned i
= 0; i
< help_tuples
.length (); i
++)
1903 const struct cl_option
*option
= cl_options
+ help_tuples
[i
].m_code
;
1904 printf (_(" Known valid arguments for %s option:\n "),
1906 for (unsigned j
= 0; j
< help_tuples
[i
].m_values
.length (); j
++)
1907 printf (" %s", help_tuples
[i
].m_values
[j
]);
1912 /* Display help for a specified type of option.
1913 The options must have ALL of the INCLUDE_FLAGS set
1914 ANY of the flags in the ANY_FLAGS set
1915 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1916 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1918 print_specific_help (unsigned int include_flags
,
1919 unsigned int exclude_flags
,
1920 unsigned int any_flags
,
1921 struct gcc_options
*opts
,
1922 unsigned int lang_mask
)
1924 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1925 const char * description
= NULL
;
1926 const char * descrip_extra
= "";
1930 /* Sanity check: Make sure that we do not have more
1931 languages than we have bits available to enumerate them. */
1932 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1934 /* If we have not done so already, obtain
1935 the desired maximum width of the output. */
1936 if (opts
->x_help_columns
== 0)
1938 opts
->x_help_columns
= get_terminal_width ();
1939 if (opts
->x_help_columns
== INT_MAX
)
1940 /* Use a reasonable default. */
1941 opts
->x_help_columns
= 80;
1944 /* Decide upon the title for the options that we are going to display. */
1945 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1947 switch (flag
& include_flags
)
1954 description
= _("The following options are target specific");
1957 description
= _("The following options control compiler warning messages");
1959 case CL_OPTIMIZATION
:
1960 description
= _("The following options control optimizations");
1963 description
= _("The following options are language-independent");
1966 description
= _("The following options control parameters");
1969 if (i
>= cl_lang_count
)
1971 if (exclude_flags
& all_langs_mask
)
1972 description
= _("The following options are specific to just the language ");
1974 description
= _("The following options are supported by the language ");
1975 descrip_extra
= lang_names
[i
];
1980 if (description
== NULL
)
1984 if (include_flags
& CL_UNDOCUMENTED
)
1985 description
= _("The following options are not documented");
1986 else if (include_flags
& CL_SEPARATE
)
1987 description
= _("The following options take separate arguments");
1988 else if (include_flags
& CL_JOINED
)
1989 description
= _("The following options take joined arguments");
1992 internal_error ("unrecognized %<include_flags 0x%x%> passed "
1993 "to %<print_specific_help%>",
2000 if (any_flags
& all_langs_mask
)
2001 description
= _("The following options are language-related");
2003 description
= _("The following options are language-independent");
2007 printf ("%s%s:\n", description
, descrip_extra
);
2008 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
2009 opts
->x_help_columns
, opts
, lang_mask
);
2012 /* Enable FDO-related flags. */
2015 enable_fdo_optimizations (struct gcc_options
*opts
,
2016 struct gcc_options
*opts_set
,
2019 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_branch_probabilities
, value
);
2020 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
2021 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_loops
, value
);
2022 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_peel_loops
, value
);
2023 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tracer
, value
);
2024 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_value_profile_transformations
,
2026 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
2027 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp
, value
);
2030 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp_clone
, 1);
2031 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, 1);
2033 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_predictive_commoning
, value
);
2034 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_split_loops
, value
);
2035 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unswitch_loops
, value
);
2036 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_gcse_after_reload
, value
);
2037 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_vectorize
, value
);
2038 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_slp_vectorize
, value
);
2039 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_version_loops_for_strides
, value
);
2040 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_vect_cost_model
,
2041 VECT_COST_MODEL_DYNAMIC
);
2042 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribute_patterns
,
2044 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_loop_interchange
, value
);
2045 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_jam
, value
);
2046 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribution
, value
);
2049 /* -f{,no-}sanitize{,-recover}= suboptions. */
2050 const struct sanitizer_opts_s sanitizer_opts
[] =
2052 #define SANITIZER_OPT(name, flags, recover, trap) \
2053 { #name, flags, sizeof #name - 1, recover, trap }
2054 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true,
2056 SANITIZER_OPT (hwaddress
, (SANITIZE_HWADDRESS
| SANITIZE_USER_HWADDRESS
),
2058 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
2060 SANITIZER_OPT (kernel
-hwaddress
,
2061 (SANITIZE_HWADDRESS
| SANITIZE_KERNEL_HWADDRESS
),
2063 SANITIZER_OPT (pointer
-compare
, SANITIZE_POINTER_COMPARE
, true, false),
2064 SANITIZER_OPT (pointer
-subtract
, SANITIZE_POINTER_SUBTRACT
, true, false),
2065 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false, false),
2066 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false, false),
2067 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true, true),
2068 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true, true),
2069 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true, true),
2070 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true, true),
2071 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true, true),
2072 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false, true),
2073 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true, true),
2074 SANITIZER_OPT (return, SANITIZE_RETURN
, false, true),
2075 SANITIZER_OPT (null
, SANITIZE_NULL
, true, true),
2076 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true, true),
2077 SANITIZER_OPT (bool, SANITIZE_BOOL
, true, true),
2078 SANITIZER_OPT (enum, SANITIZE_ENUM
, true, true),
2079 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true, true),
2080 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true, true),
2081 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true, true),
2082 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true,
2084 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true, true),
2085 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true, true),
2086 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
2088 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true, true),
2089 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true, false),
2090 SANITIZER_OPT (pointer
-overflow
, SANITIZE_POINTER_OVERFLOW
, true, true),
2091 SANITIZER_OPT (builtin
, SANITIZE_BUILTIN
, true, true),
2092 SANITIZER_OPT (shadow
-call
-stack
, SANITIZE_SHADOW_CALL_STACK
, false, false),
2093 SANITIZER_OPT (all
, ~0U, true, true),
2094 #undef SANITIZER_OPT
2095 { NULL
, 0U, 0UL, false, false }
2098 /* -fzero-call-used-regs= suboptions. */
2099 const struct zero_call_used_regs_opts_s zero_call_used_regs_opts
[] =
2101 #define ZERO_CALL_USED_REGS_OPT(name, flags) \
2103 ZERO_CALL_USED_REGS_OPT (skip
, zero_regs_flags::SKIP
),
2104 ZERO_CALL_USED_REGS_OPT (used
-gpr
-arg
, zero_regs_flags::USED_GPR_ARG
),
2105 ZERO_CALL_USED_REGS_OPT (used
-gpr
, zero_regs_flags::USED_GPR
),
2106 ZERO_CALL_USED_REGS_OPT (used
-arg
, zero_regs_flags::USED_ARG
),
2107 ZERO_CALL_USED_REGS_OPT (used
, zero_regs_flags::USED
),
2108 ZERO_CALL_USED_REGS_OPT (all
-gpr
-arg
, zero_regs_flags::ALL_GPR_ARG
),
2109 ZERO_CALL_USED_REGS_OPT (all
-gpr
, zero_regs_flags::ALL_GPR
),
2110 ZERO_CALL_USED_REGS_OPT (all
-arg
, zero_regs_flags::ALL_ARG
),
2111 ZERO_CALL_USED_REGS_OPT (all
, zero_regs_flags::ALL
),
2112 #undef ZERO_CALL_USED_REGS_OPT
2116 /* A struct for describing a run of chars within a string. */
2118 class string_fragment
2121 string_fragment (const char *start
, size_t len
)
2122 : m_start (start
), m_len (len
) {}
2124 const char *m_start
;
2128 /* Specialization of edit_distance_traits for string_fragment,
2129 for use by get_closest_sanitizer_option. */
2132 struct edit_distance_traits
<const string_fragment
&>
2134 static size_t get_length (const string_fragment
&fragment
)
2136 return fragment
.m_len
;
2139 static const char *get_string (const string_fragment
&fragment
)
2141 return fragment
.m_start
;
2145 /* Given ARG, an unrecognized sanitizer option, return the best
2146 matching sanitizer option, or NULL if there isn't one.
2147 OPTS is array of candidate sanitizer options.
2148 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or OPT_fsanitize_trap_.
2149 VALUE is non-zero for the regular form of the option, zero
2150 for the "no-" form (e.g. "-fno-sanitize-recover="). */
2153 get_closest_sanitizer_option (const string_fragment
&arg
,
2154 const struct sanitizer_opts_s
*opts
,
2155 enum opt_code code
, int value
)
2157 best_match
<const string_fragment
&, const char*> bm (arg
);
2158 for (int i
= 0; opts
[i
].name
!= NULL
; ++i
)
2160 /* -fsanitize=all is not valid, so don't offer it. */
2161 if (code
== OPT_fsanitize_
2162 && opts
[i
].flag
== ~0U
2166 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
2167 don't offer the non-recoverable options. */
2168 if (code
== OPT_fsanitize_recover_
2169 && !opts
[i
].can_recover
2173 /* For -fsanitize-trap= (and not -fno-sanitize-trap=),
2174 don't offer the non-trapping options. */
2175 if (code
== OPT_fsanitize_trap_
2176 && !opts
[i
].can_trap
2180 bm
.consider (opts
[i
].name
);
2182 return bm
.get_best_meaningful_candidate ();
2185 /* Parse comma separated sanitizer suboptions from P for option SCODE,
2186 adjust previous FLAGS and return new ones. If COMPLAIN is false,
2187 don't issue diagnostics. */
2190 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
2191 unsigned int flags
, int value
, bool complain
)
2193 enum opt_code code
= (enum opt_code
) scode
;
2199 const char *comma
= strchr (p
, ',');
2211 /* Check to see if the string matches an option class name. */
2212 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
2213 if (len
== sanitizer_opts
[i
].len
2214 && memcmp (p
, sanitizer_opts
[i
].name
, len
) == 0)
2216 /* Handle both -fsanitize and -fno-sanitize cases. */
2217 if (value
&& sanitizer_opts
[i
].flag
== ~0U)
2219 if (code
== OPT_fsanitize_
)
2222 error_at (loc
, "%<-fsanitize=all%> option is not valid");
2224 else if (code
== OPT_fsanitize_recover_
)
2225 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
2226 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
2227 | SANITIZE_SHADOW_CALL_STACK
);
2228 else /* if (code == OPT_fsanitize_trap_) */
2229 flags
|= (SANITIZE_UNDEFINED
2230 | SANITIZE_UNDEFINED_NONDEFAULT
);
2234 /* Do not enable -fsanitize-recover=unreachable and
2235 -fsanitize-recover=return if -fsanitize-recover=undefined
2237 if (code
== OPT_fsanitize_recover_
2238 && sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
2239 flags
|= (SANITIZE_UNDEFINED
2240 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
2241 else if (code
== OPT_fsanitize_trap_
2242 && sanitizer_opts
[i
].flag
== SANITIZE_VPTR
)
2243 error_at (loc
, "%<-fsanitize-trap=%s%> is not supported",
2244 sanitizer_opts
[i
].name
);
2246 flags
|= sanitizer_opts
[i
].flag
;
2249 flags
&= ~sanitizer_opts
[i
].flag
;
2254 if (! found
&& complain
)
2257 = get_closest_sanitizer_option (string_fragment (p
, len
),
2258 sanitizer_opts
, code
, value
);
2261 if (code
== OPT_fsanitize_recover_
)
2262 suffix
= "-recover";
2263 else if (code
== OPT_fsanitize_trap_
)
2270 "unrecognized argument to %<-f%ssanitize%s=%> "
2271 "option: %q.*s; did you mean %qs?",
2273 suffix
, (int) len
, p
, hint
);
2276 "unrecognized argument to %<-f%ssanitize%s=%> option: "
2277 "%q.*s", value
? "" : "no-",
2278 suffix
, (int) len
, p
);
2288 /* Parse string values of no_sanitize attribute passed in VALUE.
2289 Values are separated with comma. */
2292 parse_no_sanitize_attribute (char *value
)
2294 unsigned int flags
= 0;
2296 char *q
= strtok (value
, ",");
2300 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
2301 if (strcmp (sanitizer_opts
[i
].name
, q
) == 0)
2303 flags
|= sanitizer_opts
[i
].flag
;
2304 if (sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
2305 flags
|= SANITIZE_UNDEFINED_NONDEFAULT
;
2309 if (sanitizer_opts
[i
].name
== NULL
)
2310 warning (OPT_Wattributes
,
2311 "%qs attribute directive ignored", q
);
2313 q
= strtok (NULL
, ",");
2319 /* Parse -fzero-call-used-regs suboptions from ARG, return the FLAGS. */
2322 parse_zero_call_used_regs_options (const char *arg
)
2324 unsigned int flags
= 0;
2326 /* Check to see if the string matches a sub-option name. */
2327 for (unsigned int i
= 0; zero_call_used_regs_opts
[i
].name
!= NULL
; ++i
)
2328 if (strcmp (arg
, zero_call_used_regs_opts
[i
].name
) == 0)
2330 flags
= zero_call_used_regs_opts
[i
].flag
;
2335 error ("unrecognized argument to %<-fzero-call-used-regs=%>: %qs", arg
);
2340 /* Parse -falign-NAME format for a FLAG value. Return individual
2341 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
2342 set, print error message at LOC location. */
2345 parse_and_check_align_values (const char *flag
,
2347 auto_vec
<unsigned> &result_values
,
2351 char *str
= xstrdup (flag
);
2352 for (char *p
= strtok (str
, ":"); p
; p
= strtok (NULL
, ":"))
2355 int v
= strtol (p
, &end
, 10);
2356 if (*end
!= '\0' || v
< 0)
2359 error_at (loc
, "invalid arguments for %<-falign-%s%> option: %qs",
2365 result_values
.safe_push ((unsigned)v
);
2370 /* Check that we have a correct number of values. */
2371 if (result_values
.is_empty () || result_values
.length () > 4)
2374 error_at (loc
, "invalid number of arguments for %<-falign-%s%> "
2375 "option: %qs", name
, flag
);
2379 for (unsigned i
= 0; i
< result_values
.length (); i
++)
2380 if (result_values
[i
] > MAX_CODE_ALIGN_VALUE
)
2383 error_at (loc
, "%<-falign-%s%> is not between 0 and %d",
2384 name
, MAX_CODE_ALIGN_VALUE
);
2391 /* Check that alignment value FLAG for -falign-NAME is valid at a given
2392 location LOC. OPT_STR points to the stored -falign-NAME=argument and
2393 OPT_FLAG points to the associated -falign-NAME on/off flag. */
2396 check_alignment_argument (location_t loc
, const char *flag
, const char *name
,
2397 int *opt_flag
, const char **opt_str
)
2399 auto_vec
<unsigned> align_result
;
2400 parse_and_check_align_values (flag
, name
, align_result
, true, loc
);
2402 if (align_result
.length() >= 1 && align_result
[0] == 0)
2409 /* Parse argument of -fpatchable-function-entry option ARG and store
2410 corresponding values to PATCH_AREA_SIZE and PATCH_AREA_START.
2411 If REPORT_ERROR is set to true, generate error for a problematic
2412 option arguments. */
2415 parse_and_check_patch_area (const char *arg
, bool report_error
,
2416 HOST_WIDE_INT
*patch_area_size
,
2417 HOST_WIDE_INT
*patch_area_start
)
2419 *patch_area_size
= 0;
2420 *patch_area_start
= 0;
2425 char *patch_area_arg
= xstrdup (arg
);
2426 char *comma
= strchr (patch_area_arg
, ',');
2430 *patch_area_size
= integral_argument (patch_area_arg
);
2431 *patch_area_start
= integral_argument (comma
+ 1);
2434 *patch_area_size
= integral_argument (patch_area_arg
);
2436 if (*patch_area_size
< 0
2437 || *patch_area_size
> USHRT_MAX
2438 || *patch_area_start
< 0
2439 || *patch_area_start
> USHRT_MAX
2440 || *patch_area_size
< *patch_area_start
)
2442 error ("invalid arguments for %<-fpatchable-function-entry%>");
2444 free (patch_area_arg
);
2447 /* Print help when OPT__help_ is set. */
2450 print_help (struct gcc_options
*opts
, unsigned int lang_mask
,
2451 const char *help_option_argument
)
2453 const char *a
= help_option_argument
;
2454 unsigned int include_flags
= 0;
2455 /* Note - by default we include undocumented options when listing
2456 specific classes. If you only want to see documented options
2457 then add ",^undocumented" to the --help= option. E.g.:
2459 --help=target,^undocumented */
2460 unsigned int exclude_flags
= 0;
2462 if (lang_mask
== CL_DRIVER
)
2465 /* Walk along the argument string, parsing each word in turn.
2467 arg = [^]{word}[,{arg}]
2468 word = {optimizers|target|warnings|undocumented|
2469 params|common|<language>} */
2479 { "optimizers", CL_OPTIMIZATION
},
2480 { "target", CL_TARGET
},
2481 { "warnings", CL_WARNING
},
2482 { "undocumented", CL_UNDOCUMENTED
},
2483 { "params", CL_PARAMS
},
2484 { "joined", CL_JOINED
},
2485 { "separate", CL_SEPARATE
},
2486 { "common", CL_COMMON
},
2489 unsigned int *pflags
;
2491 unsigned int lang_flag
, specific_flag
;
2500 error ("missing argument to %qs", "--help=^");
2503 pflags
= &exclude_flags
;
2506 pflags
= &include_flags
;
2508 comma
= strchr (a
, ',');
2519 /* Check to see if the string matches an option class name. */
2520 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
2521 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
2523 specific_flag
= specifics
[i
].flag
;
2527 /* Check to see if the string matches a language name.
2528 Note - we rely upon the alpha-sorted nature of the entries in
2529 the lang_names array, specifically that shorter names appear
2530 before their longer variants. (i.e. C before C++). That way
2531 when we are attempting to match --help=c for example we will
2532 match with C first and not C++. */
2533 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
2534 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
2536 lang_flag
= 1U << i
;
2540 if (specific_flag
!= 0)
2543 *pflags
|= specific_flag
;
2546 /* The option's argument matches both the start of a
2547 language name and the start of an option class name.
2548 We have a special case for when the user has
2549 specified "--help=c", but otherwise we have to issue
2551 if (strncasecmp (a
, "c", len
) == 0)
2552 *pflags
|= lang_flag
;
2555 "%<--help%> argument %q.*s is ambiguous, "
2556 "please be more specific",
2560 else if (lang_flag
!= 0)
2561 *pflags
|= lang_flag
;
2564 "unrecognized argument to %<--help=%> option: %q.*s",
2572 /* We started using PerFunction/Optimization for parameters and
2573 a warning. We should exclude these from optimization options. */
2574 if (include_flags
& CL_OPTIMIZATION
)
2575 exclude_flags
|= CL_WARNING
;
2576 if (!(include_flags
& CL_PARAMS
))
2577 exclude_flags
|= CL_PARAMS
;
2580 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
2584 /* Handle target- and language-independent options. Return zero to
2585 generate an "unknown option" message. Only options that need
2586 extra handling need to be listed here; if you simply want
2587 DECODED->value assigned to a variable, it happens automatically. */
2590 common_handle_option (struct gcc_options
*opts
,
2591 struct gcc_options
*opts_set
,
2592 const struct cl_decoded_option
*decoded
,
2593 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
2595 const struct cl_option_handlers
*handlers
,
2596 diagnostic_context
*dc
,
2597 void (*target_option_override_hook
) (void))
2599 size_t scode
= decoded
->opt_index
;
2600 const char *arg
= decoded
->arg
;
2601 HOST_WIDE_INT value
= decoded
->value
;
2602 enum opt_code code
= (enum opt_code
) scode
;
2604 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
2610 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
2611 unsigned int undoc_mask
;
2614 if (lang_mask
== CL_DRIVER
)
2617 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
2620 target_option_override_hook ();
2621 /* First display any single language specific options. */
2622 for (i
= 0; i
< cl_lang_count
; i
++)
2624 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
2626 /* Next display any multi language specific options. */
2627 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
2628 /* Then display any remaining, non-language options. */
2629 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
2631 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
2632 opts
->x_exit_after_options
= true;
2636 case OPT__target_help
:
2637 if (lang_mask
== CL_DRIVER
)
2640 target_option_override_hook ();
2641 print_specific_help (CL_TARGET
, 0, 0, opts
, lang_mask
);
2642 opts
->x_exit_after_options
= true;
2647 help_option_arguments
.safe_push (arg
);
2648 opts
->x_exit_after_options
= true;
2653 if (lang_mask
== CL_DRIVER
)
2656 opts
->x_exit_after_options
= true;
2659 case OPT__completion_
:
2662 case OPT_fsanitize_
:
2663 opts_set
->x_flag_sanitize
= true;
2664 opts
->x_flag_sanitize
2665 = parse_sanitizer_options (arg
, loc
, code
,
2666 opts
->x_flag_sanitize
, value
, true);
2668 /* Kernel ASan implies normal ASan but does not yet support
2670 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
2672 SET_OPTION_IF_UNSET (opts
, opts_set
,
2673 param_asan_instrumentation_with_call_threshold
,
2675 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_globals
, 0);
2676 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_stack
, 0);
2677 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_protect_allocas
, 0);
2678 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_use_after_return
, 0);
2680 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_HWADDRESS
)
2682 SET_OPTION_IF_UNSET (opts
, opts_set
,
2683 param_hwasan_instrument_stack
, 0);
2684 SET_OPTION_IF_UNSET (opts
, opts_set
,
2685 param_hwasan_random_frame_tag
, 0);
2686 SET_OPTION_IF_UNSET (opts
, opts_set
,
2687 param_hwasan_instrument_allocas
, 0);
2691 case OPT_fsanitize_recover_
:
2692 opts
->x_flag_sanitize_recover
2693 = parse_sanitizer_options (arg
, loc
, code
,
2694 opts
->x_flag_sanitize_recover
, value
, true);
2697 case OPT_fsanitize_trap_
:
2698 opts
->x_flag_sanitize_trap
2699 = parse_sanitizer_options (arg
, loc
, code
,
2700 opts
->x_flag_sanitize_trap
, value
, true);
2703 case OPT_fasan_shadow_offset_
:
2707 case OPT_fsanitize_address_use_after_scope
:
2708 opts
->x_flag_sanitize_address_use_after_scope
= value
;
2711 case OPT_fsanitize_recover
:
2713 opts
->x_flag_sanitize_recover
2714 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)
2715 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2717 opts
->x_flag_sanitize_recover
2718 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2721 case OPT_fsanitize_trap
:
2723 opts
->x_flag_sanitize_trap
2724 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2726 opts
->x_flag_sanitize_trap
2727 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2735 /* Currently handled in a prescan. */
2738 case OPT_Wattributes_
:
2739 if (lang_mask
== CL_DRIVER
)
2744 error_at (loc
, "arguments ignored for %<-Wattributes=%>; use "
2745 "%<-Wno-attributes=%> instead");
2748 else if (arg
[strlen (arg
) - 1] == ',')
2750 error_at (loc
, "trailing %<,%> in arguments for "
2751 "%<-Wno-attributes=%>");
2755 add_comma_separated_to_vector (&opts
->x_flag_ignored_attributes
, arg
);
2759 dc
->warning_as_error_requested
= value
;
2763 if (lang_mask
== CL_DRIVER
)
2766 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
2767 opts
, opts_set
, loc
, dc
);
2770 case OPT_Wfatal_errors
:
2771 dc
->fatal_errors
= value
;
2774 case OPT_Wstack_usage_
:
2775 opts
->x_flag_stack_usage_info
= value
!= -1;
2778 case OPT_Wstrict_aliasing
:
2779 set_Wstrict_aliasing (opts
, value
);
2782 case OPT_Wstrict_overflow
:
2783 opts
->x_warn_strict_overflow
= (value
2784 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2788 case OPT_Wsystem_headers
:
2789 dc
->dc_warn_system_headers
= value
;
2793 opts
->x_flag_gen_aux_info
= 1;
2797 decode_d_option (arg
, opts
, loc
, dc
);
2800 case OPT_fcall_used_
:
2801 case OPT_fcall_saved_
:
2809 case OPT_fdebug_prefix_map_
:
2810 case OPT_ffile_prefix_map_
:
2811 case OPT_fprofile_prefix_map_
:
2815 case OPT_fcallgraph_info
:
2816 opts
->x_flag_callgraph_info
= CALLGRAPH_INFO_NAKED
;
2819 case OPT_fcallgraph_info_
:
2822 my_arg
= xstrdup (arg
);
2823 p
= strtok (my_arg
, ",");
2826 if (strcmp (p
, "su") == 0)
2828 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_STACK_USAGE
;
2829 opts
->x_flag_stack_usage_info
= true;
2831 else if (strcmp (p
, "da") == 0)
2832 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_DYNAMIC_ALLOC
;
2835 p
= strtok (NULL
, ",");
2841 case OPT_fdiagnostics_show_location_
:
2842 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2845 case OPT_fdiagnostics_show_caret
:
2846 dc
->show_caret
= value
;
2849 case OPT_fdiagnostics_show_labels
:
2850 dc
->show_labels_p
= value
;
2853 case OPT_fdiagnostics_show_line_numbers
:
2854 dc
->show_line_numbers_p
= value
;
2857 case OPT_fdiagnostics_color_
:
2858 diagnostic_color_init (dc
, value
);
2861 case OPT_fdiagnostics_urls_
:
2862 diagnostic_urls_init (dc
, value
);
2865 case OPT_fdiagnostics_format_
:
2866 diagnostic_output_format_init (dc
, opts
->x_dump_base_name
,
2867 (enum diagnostics_output_format
)value
);
2870 case OPT_fdiagnostics_parseable_fixits
:
2871 dc
->extra_output_kind
= (value
2872 ? EXTRA_DIAGNOSTIC_OUTPUT_fixits_v1
2873 : EXTRA_DIAGNOSTIC_OUTPUT_none
);
2876 case OPT_fdiagnostics_column_unit_
:
2877 dc
->column_unit
= (enum diagnostics_column_unit
)value
;
2880 case OPT_fdiagnostics_column_origin_
:
2881 dc
->column_origin
= value
;
2884 case OPT_fdiagnostics_escape_format_
:
2885 dc
->escape_format
= (enum diagnostics_escape_format
)value
;
2888 case OPT_fdiagnostics_show_cwe
:
2889 dc
->show_cwe
= value
;
2892 case OPT_fdiagnostics_show_rules
:
2893 dc
->show_rules
= value
;
2896 case OPT_fdiagnostics_path_format_
:
2897 dc
->path_format
= (enum diagnostic_path_format
)value
;
2900 case OPT_fdiagnostics_show_path_depths
:
2901 dc
->show_path_depths
= value
;
2904 case OPT_fdiagnostics_show_option
:
2905 dc
->show_option_requested
= value
;
2908 case OPT_fdiagnostics_minimum_margin_width_
:
2909 dc
->min_margin_width
= value
;
2916 case OPT_ffast_math
:
2917 set_fast_math_flags (opts
, value
);
2920 case OPT_funsafe_math_optimizations
:
2921 set_unsafe_math_optimizations_flags (opts
, value
);
2928 case OPT_finline_limit_
:
2929 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_single
,
2931 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_auto
,
2935 case OPT_finstrument_functions_exclude_function_list_
:
2936 add_comma_separated_to_vector
2937 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2940 case OPT_finstrument_functions_exclude_file_list_
:
2941 add_comma_separated_to_vector
2942 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2945 case OPT_fmessage_length_
:
2946 pp_set_line_maximum_length (dc
->printer
, value
);
2947 diagnostic_set_caret_max_width (dc
, value
);
2951 case OPT_fopt_info_
:
2955 case OPT_foffload_options_
:
2959 case OPT_foffload_abi_
:
2960 #ifdef ACCEL_COMPILER
2961 /* Handled in the 'mkoffload's. */
2963 error_at (loc
, "%<-foffload-abi%> option can be specified only for "
2964 "offload compiler");
2968 case OPT_fpack_struct_
:
2969 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2971 "structure alignment must be a small power of two, not %wu",
2974 opts
->x_initial_max_fld_align
= value
;
2978 case OPT_fplugin_arg_
:
2982 case OPT_fprofile_use_
:
2983 opts
->x_profile_data_prefix
= xstrdup (arg
);
2984 opts
->x_flag_profile_use
= true;
2986 /* No break here - do -fprofile-use processing. */
2988 case OPT_fprofile_use
:
2989 enable_fdo_optimizations (opts
, opts_set
, value
);
2990 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_reorder_functions
,
2992 /* Indirect call profiling should do all useful transformations
2993 speculative devirtualization does. */
2994 if (opts
->x_flag_value_profile_transformations
)
2995 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_devirtualize_speculatively
,
2999 case OPT_fauto_profile_
:
3000 opts
->x_auto_profile_file
= xstrdup (arg
);
3001 opts
->x_flag_auto_profile
= true;
3003 /* No break here - do -fauto-profile processing. */
3005 case OPT_fauto_profile
:
3006 enable_fdo_optimizations (opts
, opts_set
, value
);
3007 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_correction
, value
);
3010 case OPT_fprofile_generate_
:
3011 opts
->x_profile_data_prefix
= xstrdup (arg
);
3013 /* No break here - do -fprofile-generate processing. */
3015 case OPT_fprofile_generate
:
3016 SET_OPTION_IF_UNSET (opts
, opts_set
, profile_arc_flag
, value
);
3017 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
3018 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
3019 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, value
);
3022 case OPT_fprofile_info_section
:
3023 opts
->x_profile_info_section
= ".gcov_info";
3026 case OPT_fpatchable_function_entry_
:
3028 HOST_WIDE_INT patch_area_size
, patch_area_start
;
3029 parse_and_check_patch_area (arg
, true, &patch_area_size
,
3034 case OPT_ftree_vectorize
:
3035 /* Automatically sets -ftree-loop-vectorize and
3036 -ftree-slp-vectorize. Nothing more to do here. */
3038 case OPT_fzero_call_used_regs_
:
3039 opts
->x_flag_zero_call_used_regs
3040 = parse_zero_call_used_regs_options (arg
);
3043 case OPT_fshow_column
:
3044 dc
->show_column
= value
;
3047 case OPT_frandom_seed
:
3048 /* The real switch is -fno-random-seed. */
3054 case OPT_frandom_seed_
:
3058 case OPT_fsched_verbose_
:
3059 #ifdef INSN_SCHEDULING
3060 /* Handled with Var in common.opt. */
3066 case OPT_fsched_stalled_insns_
:
3067 opts
->x_flag_sched_stalled_insns
= value
;
3068 if (opts
->x_flag_sched_stalled_insns
== 0)
3069 opts
->x_flag_sched_stalled_insns
= -1;
3072 case OPT_fsched_stalled_insns_dep_
:
3073 opts
->x_flag_sched_stalled_insns_dep
= value
;
3076 case OPT_fstack_check_
:
3077 if (!strcmp (arg
, "no"))
3078 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
3079 else if (!strcmp (arg
, "generic"))
3080 /* This is the old stack checking method. */
3081 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
3082 ? FULL_BUILTIN_STACK_CHECK
3083 : GENERIC_STACK_CHECK
;
3084 else if (!strcmp (arg
, "specific"))
3085 /* This is the new stack checking method. */
3086 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
3087 ? FULL_BUILTIN_STACK_CHECK
3088 : STACK_CHECK_STATIC_BUILTIN
3089 ? STATIC_BUILTIN_STACK_CHECK
3090 : GENERIC_STACK_CHECK
;
3092 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
3095 case OPT_fstack_limit
:
3096 /* The real switch is -fno-stack-limit. */
3102 case OPT_fstack_limit_register_
:
3103 case OPT_fstack_limit_symbol_
:
3107 case OPT_fstack_usage
:
3108 opts
->x_flag_stack_usage
= value
;
3109 opts
->x_flag_stack_usage_info
= value
!= 0;
3113 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
3118 set_debug_level (BTF_DEBUG
, false, arg
, opts
, opts_set
, loc
);
3119 /* set the debug level to level 2, but if already at level 3,
3121 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
3122 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3126 set_debug_level (CTF_DEBUG
, false, arg
, opts
, opts_set
, loc
);
3127 /* CTF generation feeds off DWARF dies. For optimal CTF, switch debug
3128 info level to 2. If off or at level 1, set it to level 2, but if
3129 already at level 3, don't lower it. */
3130 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
3131 && opts
->x_ctf_debug_info_level
> CTFINFO_LEVEL_NONE
)
3132 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3136 if (arg
&& strlen (arg
) != 0)
3138 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
3139 "use %<-gdwarf-%s%> for DWARF version "
3140 "or %<-gdwarf%> %<-g%s%> for debug level", arg
, arg
, arg
);
3144 value
= opts
->x_dwarf_version
;
3148 if (value
< 2 || value
> 5)
3149 error_at (loc
, "dwarf version %wu is not supported", value
);
3151 opts
->x_dwarf_version
= value
;
3152 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
3156 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
3160 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
3165 /* Handled completely via specs. */
3168 case OPT_pedantic_errors
:
3169 dc
->pedantic_errors
= 1;
3170 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
3172 handlers
, opts
, opts_set
,
3177 opts
->x_flag_lto
= value
? "" : NULL
;
3181 if (strcmp (arg
, "none") != 0
3182 && strcmp (arg
, "jobserver") != 0
3183 && strcmp (arg
, "auto") != 0
3186 "unrecognized argument to %<-flto=%> option: %qs", arg
);
3190 dc
->dc_inhibit_warnings
= true;
3193 case OPT_fmax_errors_
:
3194 dc
->max_errors
= value
;
3197 case OPT_fuse_ld_bfd
:
3198 case OPT_fuse_ld_gold
:
3199 case OPT_fuse_ld_lld
:
3200 case OPT_fuse_ld_mold
:
3201 case OPT_fuse_linker_plugin
:
3202 /* No-op. Used by the driver and passed to us because it starts with f.*/
3207 opts
->x_flag_trapv
= 0;
3212 opts
->x_flag_wrapv
= 0;
3215 case OPT_fstrict_overflow
:
3216 opts
->x_flag_wrapv
= !value
;
3217 opts
->x_flag_wrapv_pointer
= !value
;
3219 opts
->x_flag_trapv
= 0;
3223 opts
->x_flag_ipa_icf_functions
= value
;
3224 opts
->x_flag_ipa_icf_variables
= value
;
3227 case OPT_falign_loops_
:
3228 check_alignment_argument (loc
, arg
, "loops",
3229 &opts
->x_flag_align_loops
,
3230 &opts
->x_str_align_loops
);
3233 case OPT_falign_jumps_
:
3234 check_alignment_argument (loc
, arg
, "jumps",
3235 &opts
->x_flag_align_jumps
,
3236 &opts
->x_str_align_jumps
);
3239 case OPT_falign_labels_
:
3240 check_alignment_argument (loc
, arg
, "labels",
3241 &opts
->x_flag_align_labels
,
3242 &opts
->x_str_align_labels
);
3245 case OPT_falign_functions_
:
3246 check_alignment_argument (loc
, arg
, "functions",
3247 &opts
->x_flag_align_functions
,
3248 &opts
->x_str_align_functions
);
3252 /* It is documented that we silently ignore silly values. */
3253 if (value
>= 1 && value
<= 100)
3254 dc
->tabstop
= value
;
3257 case OPT_freport_bug
:
3258 dc
->report_bug
= value
;
3261 case OPT_fmultiflags
:
3262 gcc_checking_assert (lang_mask
== CL_DRIVER
);
3266 /* If the flag was handled in a standard way, assume the lack of
3267 processing here is intentional. */
3268 gcc_assert (option_flag_var (scode
, opts
));
3272 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
3277 /* Used to set the level of strict aliasing warnings in OPTS,
3278 when no level is specified (i.e., when -Wstrict-aliasing, and not
3279 -Wstrict-aliasing=level was given).
3280 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
3281 and 0 otherwise. After calling this function, wstrict_aliasing will be
3282 set to the default value of -Wstrict_aliasing=level, currently 3. */
3284 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
3286 gcc_assert (onoff
== 0 || onoff
== 1);
3288 opts
->x_warn_strict_aliasing
= 3;
3290 opts
->x_warn_strict_aliasing
= 0;
3293 /* The following routines are useful in setting all the flags that
3294 -ffast-math and -fno-fast-math imply. */
3296 set_fast_math_flags (struct gcc_options
*opts
, int set
)
3298 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
3300 opts
->x_flag_unsafe_math_optimizations
= set
;
3301 set_unsafe_math_optimizations_flags (opts
, set
);
3303 if (!opts
->frontend_set_flag_finite_math_only
)
3304 opts
->x_flag_finite_math_only
= set
;
3305 if (!opts
->frontend_set_flag_errno_math
)
3306 opts
->x_flag_errno_math
= !set
;
3309 if (opts
->frontend_set_flag_excess_precision
== EXCESS_PRECISION_DEFAULT
)
3310 opts
->x_flag_excess_precision
3311 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
3312 if (!opts
->frontend_set_flag_signaling_nans
)
3313 opts
->x_flag_signaling_nans
= 0;
3314 if (!opts
->frontend_set_flag_rounding_math
)
3315 opts
->x_flag_rounding_math
= 0;
3316 if (!opts
->frontend_set_flag_cx_limited_range
)
3317 opts
->x_flag_cx_limited_range
= 1;
3321 /* When -funsafe-math-optimizations is set the following
3322 flags are set as well. */
3324 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
3326 if (!opts
->frontend_set_flag_trapping_math
)
3327 opts
->x_flag_trapping_math
= !set
;
3328 if (!opts
->frontend_set_flag_signed_zeros
)
3329 opts
->x_flag_signed_zeros
= !set
;
3330 if (!opts
->frontend_set_flag_associative_math
)
3331 opts
->x_flag_associative_math
= set
;
3332 if (!opts
->frontend_set_flag_reciprocal_math
)
3333 opts
->x_flag_reciprocal_math
= set
;
3336 /* Return true iff flags in OPTS are set as if -ffast-math. */
3338 fast_math_flags_set_p (const struct gcc_options
*opts
)
3340 return (!opts
->x_flag_trapping_math
3341 && opts
->x_flag_unsafe_math_optimizations
3342 && opts
->x_flag_finite_math_only
3343 && !opts
->x_flag_signed_zeros
3344 && !opts
->x_flag_errno_math
3345 && opts
->x_flag_excess_precision
== EXCESS_PRECISION_FAST
);
3348 /* Return true iff flags are set as if -ffast-math but using the flags stored
3349 in the struct cl_optimization structure. */
3351 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
3353 return (!opt
->x_flag_trapping_math
3354 && opt
->x_flag_unsafe_math_optimizations
3355 && opt
->x_flag_finite_math_only
3356 && !opt
->x_flag_signed_zeros
3357 && !opt
->x_flag_errno_math
);
3360 /* Handle a debug output -g switch for options OPTS
3361 (OPTS_SET->x_write_symbols storing whether a debug format was passed
3362 explicitly), location LOC. EXTENDED is true or false to support
3363 extended output (2 is special and means "-ggdb" was given). */
3365 set_debug_level (uint32_t dinfo
, int extended
, const char *arg
,
3366 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
3369 if (dinfo
== NO_DEBUG
)
3371 if (opts
->x_write_symbols
== NO_DEBUG
)
3373 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
3377 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
3378 if (opts
->x_write_symbols
& CTF_DEBUG
)
3379 opts
->x_write_symbols
|= DWARF2_DEBUG
;
3381 opts
->x_write_symbols
= DWARF2_DEBUG
;
3385 if (opts
->x_write_symbols
== NO_DEBUG
)
3386 warning_at (loc
, 0, "target system does not support debug output");
3388 else if ((opts
->x_write_symbols
& CTF_DEBUG
)
3389 || (opts
->x_write_symbols
& BTF_DEBUG
))
3391 opts
->x_write_symbols
|= DWARF2_DEBUG
;
3392 opts_set
->x_write_symbols
|= DWARF2_DEBUG
;
3397 /* Make and retain the choice if both CTF and DWARF debug info are to
3399 if (((dinfo
== DWARF2_DEBUG
) || (dinfo
== CTF_DEBUG
))
3400 && ((opts
->x_write_symbols
== (DWARF2_DEBUG
|CTF_DEBUG
))
3401 || (opts
->x_write_symbols
== DWARF2_DEBUG
)
3402 || (opts
->x_write_symbols
== CTF_DEBUG
)))
3404 opts
->x_write_symbols
|= dinfo
;
3405 opts_set
->x_write_symbols
|= dinfo
;
3407 /* However, CTF and BTF are not allowed together at this time. */
3408 else if (((dinfo
== DWARF2_DEBUG
) || (dinfo
== BTF_DEBUG
))
3409 && ((opts
->x_write_symbols
== (DWARF2_DEBUG
|BTF_DEBUG
))
3410 || (opts
->x_write_symbols
== DWARF2_DEBUG
)
3411 || (opts
->x_write_symbols
== BTF_DEBUG
)))
3413 opts
->x_write_symbols
|= dinfo
;
3414 opts_set
->x_write_symbols
|= dinfo
;
3418 /* Does it conflict with an already selected debug format? */
3419 if (opts_set
->x_write_symbols
!= NO_DEBUG
3420 && opts
->x_write_symbols
!= NO_DEBUG
3421 && dinfo
!= opts
->x_write_symbols
)
3423 gcc_assert (debug_set_count (dinfo
) <= 1);
3424 error_at (loc
, "debug format %qs conflicts with prior selection",
3425 debug_type_names
[debug_set_to_format (dinfo
)]);
3427 opts
->x_write_symbols
= dinfo
;
3428 opts_set
->x_write_symbols
= dinfo
;
3432 if (dinfo
!= BTF_DEBUG
)
3434 /* A debug flag without a level defaults to level 2.
3435 If off or at level 1, set it to level 2, but if already
3436 at level 3, don't lower it. */
3439 if (dinfo
== CTF_DEBUG
)
3440 opts
->x_ctf_debug_info_level
= CTFINFO_LEVEL_NORMAL
;
3441 else if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
3442 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3446 int argval
= integral_argument (arg
);
3448 error_at (loc
, "unrecognized debug output level %qs", arg
);
3449 else if (argval
> 3)
3450 error_at (loc
, "debug output level %qs is too high", arg
);
3453 if (dinfo
== CTF_DEBUG
)
3454 opts
->x_ctf_debug_info_level
3455 = (enum ctf_debug_info_levels
) argval
;
3457 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
3461 else if (*arg
!= '\0')
3462 error_at (loc
, "unrecognized btf debug output level %qs", arg
);
3465 /* Arrange to dump core on error for diagnostic context DC. (The
3466 regular error message is still printed first, except in the case of
3470 setup_core_dumping (diagnostic_context
*dc
)
3473 signal (SIGABRT
, SIG_DFL
);
3475 #if defined(HAVE_SETRLIMIT)
3478 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
3479 fatal_error (input_location
, "getting core file size maximum limit: %m");
3480 rlim
.rlim_cur
= rlim
.rlim_max
;
3481 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
3482 fatal_error (input_location
,
3483 "setting core file size limit to maximum: %m");
3486 diagnostic_abort_on_error (dc
);
3489 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
3490 diagnostic context DC. */
3493 decode_d_option (const char *arg
, struct gcc_options
*opts
,
3494 location_t loc
, diagnostic_context
*dc
)
3502 opts
->x_flag_debug_asm
= 1;
3505 opts
->x_flag_print_asm_name
= 1;
3508 opts
->x_flag_dump_rtl_in_asm
= 1;
3509 opts
->x_flag_print_asm_name
= 1;
3512 opts
->x_rtl_dump_and_exit
= 1;
3514 case 'D': /* These are handled by the preprocessor. */
3521 setup_core_dumping (dc
);
3524 opts
->x_flag_dump_all_passed
= true;
3528 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
3533 /* Enable (or disable if VALUE is 0) a warning option ARG (language
3534 mask LANG_MASK, option handlers HANDLERS) as an error for option
3535 structures OPTS and OPTS_SET, diagnostic context DC (possibly
3536 NULL), location LOC. This is used by -Werror=. */
3539 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
3540 const struct cl_option_handlers
*handlers
,
3541 struct gcc_options
*opts
,
3542 struct gcc_options
*opts_set
,
3543 location_t loc
, diagnostic_context
*dc
)
3548 new_option
= XNEWVEC (char, strlen (arg
) + 2);
3549 new_option
[0] = 'W';
3550 strcpy (new_option
+ 1, arg
);
3551 option_index
= find_opt (new_option
, lang_mask
);
3552 if (option_index
== OPT_SPECIAL_unknown
)
3555 const char *hint
= op
.suggest_option (new_option
);
3557 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>;"
3558 " did you mean %<-%s%>?", value
? "" : "no-",
3559 arg
, new_option
, hint
);
3561 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>",
3562 value
? "" : "no-", arg
, new_option
);
3564 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
3565 error_at (loc
, "%<-Werror=%s%>: %<-%s%> is not an option that "
3566 "controls warnings", arg
, new_option
);
3569 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
3570 const char *arg
= NULL
;
3572 if (cl_options
[option_index
].flags
& CL_JOINED
)
3573 arg
= new_option
+ cl_options
[option_index
].opt_len
;
3574 control_warning_option (option_index
, (int) kind
, arg
, value
,
3576 handlers
, opts
, opts_set
, dc
);
3581 /* Return malloced memory for the name of the option OPTION_INDEX
3582 which enabled a diagnostic (context CONTEXT), originally of type
3583 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
3587 option_name (diagnostic_context
*context
, int option_index
,
3588 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
3592 /* A warning classified as an error. */
3593 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
3594 && diag_kind
== DK_ERROR
)
3595 return concat (cl_options
[OPT_Werror_
].opt_text
,
3596 /* Skip over "-W". */
3597 cl_options
[option_index
].opt_text
+ 2,
3599 /* A warning with option. */
3601 return xstrdup (cl_options
[option_index
].opt_text
);
3603 /* A warning without option classified as an error. */
3604 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
3605 || diag_kind
== DK_WARNING
)
3606 && context
->warning_as_error_requested
)
3607 return xstrdup (cl_options
[OPT_Werror
].opt_text
);
3612 /* Get the page within the documentation for this option. */
3615 get_option_html_page (int option_index
)
3617 const cl_option
*cl_opt
= &cl_options
[option_index
];
3619 /* Analyzer options are on their own page. */
3620 if (strstr (cl_opt
->opt_text
, "analyzer-"))
3621 return "gcc/Static-Analyzer-Options.html";
3623 /* Handle -flto= option. */
3624 if (strstr (cl_opt
->opt_text
, "flto"))
3625 return "gcc/Optimize-Options.html";
3628 if ((cl_opt
->flags
& CL_Fortran
) != 0
3629 /* If it is option common to both C/C++ and Fortran, it is documented
3630 in gcc/ rather than gfortran/ docs. */
3631 && (cl_opt
->flags
& CL_C
) == 0
3633 && (cl_opt
->flags
& CL_CXX
) == 0
3636 return "gfortran/Error-and-Warning-Options.html";
3639 return "gcc/Warning-Options.html";
3642 /* Return malloced memory for a URL describing the option OPTION_INDEX
3643 which enabled a diagnostic (context CONTEXT). */
3646 get_option_url (diagnostic_context
*, int option_index
)
3649 return concat (/* DOCUMENTATION_ROOT_URL should be supplied via -D by
3650 the Makefile (see --with-documentation-root-url), and
3651 should have a trailing slash. */
3652 DOCUMENTATION_ROOT_URL
,
3654 /* get_option_html_page will return something like
3655 "gcc/Warning-Options.html". */
3656 get_option_html_page (option_index
),
3658 /* Expect an anchor of the form "index-Wfoo" e.g.
3659 <a name="index-Wformat"></a>, and thus an id within
3660 the URL of "#index-Wformat". */
3661 "#index", cl_options
[option_index
].opt_text
,
3667 /* Return a heap allocated producer with command line options. */
3670 gen_command_line_string (cl_decoded_option
*options
,
3671 unsigned int options_count
)
3673 auto_vec
<const char *> switches
;
3674 char *options_string
, *tail
;
3678 for (unsigned i
= 0; i
< options_count
; i
++)
3679 switch (options
[i
].opt_index
)
3684 case OPT_dumpbase_ext
:
3694 case OPT_SPECIAL_unknown
:
3695 case OPT_SPECIAL_ignore
:
3696 case OPT_SPECIAL_warn_removed
:
3697 case OPT_SPECIAL_program_name
:
3698 case OPT_SPECIAL_input_file
:
3699 case OPT_grecord_gcc_switches
:
3700 case OPT_frecord_gcc_switches
:
3701 case OPT__output_pch
:
3702 case OPT_fdiagnostics_show_location_
:
3703 case OPT_fdiagnostics_show_option
:
3704 case OPT_fdiagnostics_show_caret
:
3705 case OPT_fdiagnostics_show_labels
:
3706 case OPT_fdiagnostics_show_line_numbers
:
3707 case OPT_fdiagnostics_color_
:
3708 case OPT_fdiagnostics_format_
:
3709 case OPT_fverbose_asm
:
3713 case OPT_nostdinc__
:
3714 case OPT_fpreprocessed
:
3715 case OPT_fltrans_output_list_
:
3716 case OPT_fresolution_
:
3717 case OPT_fdebug_prefix_map_
:
3718 case OPT_fmacro_prefix_map_
:
3719 case OPT_ffile_prefix_map_
:
3720 case OPT_fprofile_prefix_map_
:
3721 case OPT_fcompare_debug
:
3723 case OPT_fchecking_
:
3728 const char *lto_canonical
= "-flto";
3729 switches
.safe_push (lto_canonical
);
3730 len
+= strlen (lto_canonical
) + 1;
3734 if (cl_options
[options
[i
].opt_index
].flags
3735 & CL_NO_DWARF_RECORD
)
3737 gcc_checking_assert (options
[i
].canonical_option
[0][0] == '-');
3738 switch (options
[i
].canonical_option
[0][1])
3745 if (strncmp (options
[i
].canonical_option
[0] + 2,
3752 switches
.safe_push (options
[i
].orig_option_with_args_text
);
3753 len
+= strlen (options
[i
].orig_option_with_args_text
) + 1;
3757 options_string
= XNEWVEC (char, len
+ 1);
3758 tail
= options_string
;
3761 FOR_EACH_VEC_ELT (switches
, i
, p
)
3764 memcpy (tail
, p
, len
);
3766 if (i
!= switches
.length () - 1)
3774 return options_string
;
3777 /* Return a heap allocated producer string including command line options. */
3780 gen_producer_string (const char *language_string
, cl_decoded_option
*options
,
3781 unsigned int options_count
)
3783 char *cmdline
= gen_command_line_string (options
, options_count
);
3784 char *combined
= concat (language_string
, " ", version_string
, " ",
3792 namespace selftest
{
3794 /* Verify that get_option_html_page works as expected. */
3797 test_get_option_html_page ()
3799 ASSERT_STREQ (get_option_html_page (OPT_Wcpp
), "gcc/Warning-Options.html");
3800 ASSERT_STREQ (get_option_html_page (OPT_Wanalyzer_double_free
),
3801 "gcc/Static-Analyzer-Options.html");
3803 ASSERT_STREQ (get_option_html_page (OPT_Wline_truncation
),
3804 "gfortran/Error-and-Warning-Options.html");
3808 /* Verify EnumSet and EnumBitSet requirements. */
3813 for (unsigned i
= 0; i
< cl_options_count
; ++i
)
3814 if (cl_options
[i
].var_type
== CLVC_ENUM
3815 && cl_options
[i
].var_value
!= CLEV_NORMAL
)
3817 const struct cl_enum
*e
= &cl_enums
[cl_options
[i
].var_enum
];
3818 unsigned HOST_WIDE_INT used_sets
= 0;
3819 unsigned HOST_WIDE_INT mask
= 0;
3820 unsigned highest_set
= 0;
3821 for (unsigned j
= 0; e
->values
[j
].arg
; ++j
)
3823 unsigned set
= e
->values
[j
].flags
>> CL_ENUM_SET_SHIFT
;
3824 if (cl_options
[i
].var_value
== CLEV_BITSET
)
3826 /* For EnumBitSet Set shouldn't be used and Value should
3827 be a power of two. */
3828 ASSERT_TRUE (set
== 0);
3829 ASSERT_TRUE (pow2p_hwi (e
->values
[j
].value
));
3832 /* Test that enumerators referenced in EnumSet have all
3833 Set(n) on them within the valid range. */
3834 ASSERT_TRUE (set
>= 1 && set
<= HOST_BITS_PER_WIDE_INT
);
3835 highest_set
= MAX (set
, highest_set
);
3836 used_sets
|= HOST_WIDE_INT_1U
<< (set
- 1);
3838 if (cl_options
[i
].var_value
== CLEV_BITSET
)
3840 /* If there is just one set, no point to using EnumSet. */
3841 ASSERT_TRUE (highest_set
>= 2);
3842 /* Test that there are no gaps in between the sets. */
3843 if (highest_set
== HOST_BITS_PER_WIDE_INT
)
3844 ASSERT_TRUE (used_sets
== HOST_WIDE_INT_M1U
);
3846 ASSERT_TRUE (used_sets
== (HOST_WIDE_INT_1U
<< highest_set
) - 1);
3847 for (unsigned int j
= 1; j
<= highest_set
; ++j
)
3849 unsigned HOST_WIDE_INT this_mask
= 0;
3850 for (unsigned k
= 0; e
->values
[k
].arg
; ++k
)
3852 unsigned set
= e
->values
[j
].flags
>> CL_ENUM_SET_SHIFT
;
3854 this_mask
|= e
->values
[j
].value
;
3856 ASSERT_TRUE ((mask
& this_mask
) == 0);
3862 /* Run all of the selftests within this file. */
3867 test_get_option_html_page ();
3871 } // namespace selftest
3873 #endif /* #if CHECKING_P */