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
, DBX_DEBUG
, DWARF2_DEBUG
, XCOFF_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 #ifdef INSN_SCHEDULING
662 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
663 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_fschedule_insns
, NULL
, 1 },
666 /* -O3 and -Os optimizations. */
668 /* -O3 optimizations. */
669 { OPT_LEVELS_3_PLUS
, OPT_fgcse_after_reload
, NULL
, 1 },
670 { OPT_LEVELS_3_PLUS
, OPT_fipa_cp_clone
, NULL
, 1 },
671 { OPT_LEVELS_3_PLUS
, OPT_floop_interchange
, NULL
, 1 },
672 { OPT_LEVELS_3_PLUS
, OPT_floop_unroll_and_jam
, NULL
, 1 },
673 { OPT_LEVELS_3_PLUS
, OPT_fpeel_loops
, NULL
, 1 },
674 { OPT_LEVELS_3_PLUS
, OPT_fpredictive_commoning
, NULL
, 1 },
675 { OPT_LEVELS_3_PLUS
, OPT_fsplit_loops
, NULL
, 1 },
676 { OPT_LEVELS_3_PLUS
, OPT_fsplit_paths
, NULL
, 1 },
677 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribution
, NULL
, 1 },
678 { OPT_LEVELS_3_PLUS
, OPT_ftree_partial_pre
, NULL
, 1 },
679 { OPT_LEVELS_3_PLUS
, OPT_funswitch_loops
, NULL
, 1 },
680 { OPT_LEVELS_3_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_DYNAMIC
},
681 { OPT_LEVELS_3_PLUS
, OPT_fversion_loops_for_strides
, NULL
, 1 },
683 /* -O3 parameters. */
684 { OPT_LEVELS_3_PLUS
, OPT__param_max_inline_insns_auto_
, NULL
, 30 },
685 { OPT_LEVELS_3_PLUS
, OPT__param_early_inlining_insns_
, NULL
, 14 },
686 { OPT_LEVELS_3_PLUS
, OPT__param_inline_heuristics_hint_percent_
, NULL
, 600 },
687 { OPT_LEVELS_3_PLUS
, OPT__param_inline_min_speedup_
, NULL
, 15 },
688 { OPT_LEVELS_3_PLUS
, OPT__param_max_inline_insns_single_
, NULL
, 200 },
690 /* -Ofast adds optimizations to -O3. */
691 { OPT_LEVELS_FAST
, OPT_ffast_math
, NULL
, 1 },
692 { OPT_LEVELS_FAST
, OPT_fallow_store_data_races
, NULL
, 1 },
693 { OPT_LEVELS_FAST
, OPT_fsemantic_interposition
, NULL
, 0 },
695 { OPT_LEVELS_NONE
, 0, NULL
, 0 }
698 /* Default the options in OPTS and OPTS_SET based on the optimization
699 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
701 default_options_optimization (struct gcc_options
*opts
,
702 struct gcc_options
*opts_set
,
703 struct cl_decoded_option
*decoded_options
,
704 unsigned int decoded_options_count
,
706 unsigned int lang_mask
,
707 const struct cl_option_handlers
*handlers
,
708 diagnostic_context
*dc
)
712 bool openacc_mode
= false;
714 /* Scan to see what optimization level has been specified. That will
715 determine the default value of many flags. */
716 for (i
= 1; i
< decoded_options_count
; i
++)
718 struct cl_decoded_option
*opt
= &decoded_options
[i
];
719 switch (opt
->opt_index
)
722 if (*opt
->arg
== '\0')
724 opts
->x_optimize
= 1;
725 opts
->x_optimize_size
= 0;
726 opts
->x_optimize_fast
= 0;
727 opts
->x_optimize_debug
= 0;
731 const int optimize_val
= integral_argument (opt
->arg
);
732 if (optimize_val
== -1)
733 error_at (loc
, "argument to %<-O%> should be a non-negative "
734 "integer, %<g%>, %<s%>, %<z%> or %<fast%>");
737 opts
->x_optimize
= optimize_val
;
738 if ((unsigned int) opts
->x_optimize
> 255)
739 opts
->x_optimize
= 255;
740 opts
->x_optimize_size
= 0;
741 opts
->x_optimize_fast
= 0;
742 opts
->x_optimize_debug
= 0;
748 opts
->x_optimize_size
= 1;
750 /* Optimizing for size forces optimize to be 2. */
751 opts
->x_optimize
= 2;
752 opts
->x_optimize_fast
= 0;
753 opts
->x_optimize_debug
= 0;
757 opts
->x_optimize_size
= 2;
759 /* Optimizing for size forces optimize to be 2. */
760 opts
->x_optimize
= 2;
761 opts
->x_optimize_fast
= 0;
762 opts
->x_optimize_debug
= 0;
766 /* -Ofast only adds flags to -O3. */
767 opts
->x_optimize_size
= 0;
768 opts
->x_optimize
= 3;
769 opts
->x_optimize_fast
= 1;
770 opts
->x_optimize_debug
= 0;
774 /* -Og selects optimization level 1. */
775 opts
->x_optimize_size
= 0;
776 opts
->x_optimize
= 1;
777 opts
->x_optimize_fast
= 0;
778 opts
->x_optimize_debug
= 1;
787 /* Ignore other options in this prescan. */
792 maybe_default_options (opts
, opts_set
, default_options_table
,
793 opts
->x_optimize
, opts
->x_optimize_size
,
794 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
795 lang_mask
, handlers
, loc
, dc
);
797 /* -O2 param settings. */
798 opt2
= (opts
->x_optimize
>= 2);
801 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_pta
, true);
803 /* Track fields in field-sensitive alias analysis. */
805 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_fields_for_field_sensitive
,
808 if (opts
->x_optimize_size
)
809 /* We want to crossjump as much as possible. */
810 SET_OPTION_IF_UNSET (opts
, opts_set
, param_min_crossjump_insns
, 1);
812 /* Restrict the amount of work combine does at -Og while retaining
813 most of its useful transforms. */
814 if (opts
->x_optimize_debug
)
815 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_combine_insns
, 2);
817 /* Allow default optimizations to be specified on a per-machine basis. */
818 maybe_default_options (opts
, opts_set
,
819 targetm_common
.option_optimization_table
,
820 opts
->x_optimize
, opts
->x_optimize_size
,
821 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
822 lang_mask
, handlers
, loc
, dc
);
825 /* Control IPA optimizations based on different live patching LEVEL. */
827 control_options_for_live_patching (struct gcc_options
*opts
,
828 struct gcc_options
*opts_set
,
829 enum live_patching_level level
,
832 gcc_assert (level
> LIVE_PATCHING_NONE
);
836 case LIVE_PATCHING_INLINE_ONLY_STATIC
:
837 #define LIVE_PATCHING_OPTION "-flive-patching=inline-only-static"
838 if (opts_set
->x_flag_ipa_cp_clone
&& opts
->x_flag_ipa_cp_clone
)
839 error_at (loc
, "%qs is incompatible with %qs",
840 "-fipa-cp-clone", LIVE_PATCHING_OPTION
);
842 opts
->x_flag_ipa_cp_clone
= 0;
844 if (opts_set
->x_flag_ipa_sra
&& opts
->x_flag_ipa_sra
)
845 error_at (loc
, "%qs is incompatible with %qs",
846 "-fipa-sra", LIVE_PATCHING_OPTION
);
848 opts
->x_flag_ipa_sra
= 0;
850 if (opts_set
->x_flag_partial_inlining
&& opts
->x_flag_partial_inlining
)
851 error_at (loc
, "%qs is incompatible with %qs",
852 "-fpartial-inlining", LIVE_PATCHING_OPTION
);
854 opts
->x_flag_partial_inlining
= 0;
856 if (opts_set
->x_flag_ipa_cp
&& opts
->x_flag_ipa_cp
)
857 error_at (loc
, "%qs is incompatible with %qs",
858 "-fipa-cp", LIVE_PATCHING_OPTION
);
860 opts
->x_flag_ipa_cp
= 0;
863 case LIVE_PATCHING_INLINE_CLONE
:
864 #undef LIVE_PATCHING_OPTION
865 #define LIVE_PATCHING_OPTION "-flive-patching=inline-only-static|inline-clone"
866 /* live patching should disable whole-program optimization. */
867 if (opts_set
->x_flag_whole_program
&& opts
->x_flag_whole_program
)
868 error_at (loc
, "%qs is incompatible with %qs",
869 "-fwhole-program", LIVE_PATCHING_OPTION
);
871 opts
->x_flag_whole_program
= 0;
873 /* visibility change should be excluded by !flag_whole_program
874 && !in_lto_p && !flag_ipa_cp_clone && !flag_ipa_sra
875 && !flag_partial_inlining. */
877 if (opts_set
->x_flag_ipa_pta
&& opts
->x_flag_ipa_pta
)
878 error_at (loc
, "%qs is incompatible with %qs",
879 "-fipa-pta", LIVE_PATCHING_OPTION
);
881 opts
->x_flag_ipa_pta
= 0;
883 if (opts_set
->x_flag_ipa_reference
&& opts
->x_flag_ipa_reference
)
884 error_at (loc
, "%qs is incompatible with %qs",
885 "-fipa-reference", LIVE_PATCHING_OPTION
);
887 opts
->x_flag_ipa_reference
= 0;
889 if (opts_set
->x_flag_ipa_ra
&& opts
->x_flag_ipa_ra
)
890 error_at (loc
, "%qs is incompatible with %qs",
891 "-fipa-ra", LIVE_PATCHING_OPTION
);
893 opts
->x_flag_ipa_ra
= 0;
895 if (opts_set
->x_flag_ipa_icf
&& opts
->x_flag_ipa_icf
)
896 error_at (loc
, "%qs is incompatible with %qs",
897 "-fipa-icf", LIVE_PATCHING_OPTION
);
899 opts
->x_flag_ipa_icf
= 0;
901 if (opts_set
->x_flag_ipa_icf_functions
&& opts
->x_flag_ipa_icf_functions
)
902 error_at (loc
, "%qs is incompatible with %qs",
903 "-fipa-icf-functions", LIVE_PATCHING_OPTION
);
905 opts
->x_flag_ipa_icf_functions
= 0;
907 if (opts_set
->x_flag_ipa_icf_variables
&& opts
->x_flag_ipa_icf_variables
)
908 error_at (loc
, "%qs is incompatible with %qs",
909 "-fipa-icf-variables", LIVE_PATCHING_OPTION
);
911 opts
->x_flag_ipa_icf_variables
= 0;
913 if (opts_set
->x_flag_ipa_bit_cp
&& opts
->x_flag_ipa_bit_cp
)
914 error_at (loc
, "%qs is incompatible with %qs",
915 "-fipa-bit-cp", LIVE_PATCHING_OPTION
);
917 opts
->x_flag_ipa_bit_cp
= 0;
919 if (opts_set
->x_flag_ipa_vrp
&& opts
->x_flag_ipa_vrp
)
920 error_at (loc
, "%qs is incompatible with %qs",
921 "-fipa-vrp", LIVE_PATCHING_OPTION
);
923 opts
->x_flag_ipa_vrp
= 0;
925 if (opts_set
->x_flag_ipa_pure_const
&& opts
->x_flag_ipa_pure_const
)
926 error_at (loc
, "%qs is incompatible with %qs",
927 "-fipa-pure-const", LIVE_PATCHING_OPTION
);
929 opts
->x_flag_ipa_pure_const
= 0;
931 if (opts_set
->x_flag_ipa_modref
&& opts
->x_flag_ipa_modref
)
933 "%<-fipa-modref%> is incompatible with %qs",
934 LIVE_PATCHING_OPTION
);
936 opts
->x_flag_ipa_modref
= 0;
938 /* FIXME: disable unreachable code removal. */
940 /* discovery of functions/variables with no address taken. */
941 if (opts_set
->x_flag_ipa_reference_addressable
942 && opts
->x_flag_ipa_reference_addressable
)
943 error_at (loc
, "%qs is incompatible with %qs",
944 "-fipa-reference-addressable", LIVE_PATCHING_OPTION
);
946 opts
->x_flag_ipa_reference_addressable
= 0;
948 /* ipa stack alignment propagation. */
949 if (opts_set
->x_flag_ipa_stack_alignment
950 && opts
->x_flag_ipa_stack_alignment
)
951 error_at (loc
, "%qs is incompatible with %qs",
952 "-fipa-stack-alignment", LIVE_PATCHING_OPTION
);
954 opts
->x_flag_ipa_stack_alignment
= 0;
960 #undef LIVE_PATCHING_OPTION
963 /* --help option argument if set. */
964 vec
<const char *> help_option_arguments
;
966 /* Return the string name describing a sanitizer argument which has been
967 provided on the command line and has set this particular flag. */
969 find_sanitizer_argument (struct gcc_options
*opts
, unsigned int flags
)
971 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
973 /* Need to find the sanitizer_opts element which:
974 a) Could have set the flags requested.
975 b) Has been set on the command line.
977 Can have (a) without (b) if the flag requested is e.g.
978 SANITIZE_ADDRESS, since both -fsanitize=address and
979 -fsanitize=kernel-address set this flag.
981 Can have (b) without (a) by requesting more than one sanitizer on the
983 if ((sanitizer_opts
[i
].flag
& opts
->x_flag_sanitize
)
984 != sanitizer_opts
[i
].flag
)
986 if ((sanitizer_opts
[i
].flag
& flags
) != flags
)
988 return sanitizer_opts
[i
].name
;
994 /* Report an error to the user about sanitizer options they have requested
995 which have set conflicting flags.
997 LEFT and RIGHT indicate sanitizer flags which conflict with each other, this
998 function reports an error if both have been set in OPTS->x_flag_sanitize and
999 ensures the error identifies the requested command line options that have
1002 report_conflicting_sanitizer_options (struct gcc_options
*opts
, location_t loc
,
1003 unsigned int left
, unsigned int right
)
1005 unsigned int left_seen
= (opts
->x_flag_sanitize
& left
);
1006 unsigned int right_seen
= (opts
->x_flag_sanitize
& right
);
1007 if (left_seen
&& right_seen
)
1009 const char* left_arg
= find_sanitizer_argument (opts
, left_seen
);
1010 const char* right_arg
= find_sanitizer_argument (opts
, right_seen
);
1011 gcc_assert (left_arg
&& right_arg
);
1013 "%<-fsanitize=%s%> is incompatible with %<-fsanitize=%s%>",
1014 left_arg
, right_arg
);
1018 /* After all options at LOC have been read into OPTS and OPTS_SET,
1019 finalize settings of those options and diagnose incompatible
1022 finish_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
1025 if (opts
->x_dump_base_name
1026 && ! opts
->x_dump_base_name_prefixed
)
1028 const char *sep
= opts
->x_dump_base_name
;
1031 if (IS_DIR_SEPARATOR (*sep
))
1035 /* If dump_base_path contains subdirectories, don't prepend
1037 else if (opts
->x_dump_dir_name
)
1038 /* We have a DUMP_DIR_NAME, prepend that. */
1039 opts
->x_dump_base_name
= opts_concat (opts
->x_dump_dir_name
,
1040 opts
->x_dump_base_name
, NULL
);
1042 /* It is definitely prefixed now. */
1043 opts
->x_dump_base_name_prefixed
= true;
1046 /* Handle related options for unit-at-a-time, toplevel-reorder, and
1048 if (!opts
->x_flag_unit_at_a_time
)
1050 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
1051 error_at (loc
, "section anchors must be disabled when unit-at-a-time "
1053 opts
->x_flag_section_anchors
= 0;
1054 if (opts
->x_flag_toplevel_reorder
== 1)
1055 error_at (loc
, "toplevel reorder must be disabled when unit-at-a-time "
1057 opts
->x_flag_toplevel_reorder
= 0;
1060 /* -fself-test depends on the state of the compiler prior to
1061 compiling anything. Ideally it should be run on an empty source
1062 file. However, in case we get run with actual source, assume
1063 -fsyntax-only which will inhibit any compiler initialization
1064 which may confuse the self tests. */
1065 if (opts
->x_flag_self_test
)
1066 opts
->x_flag_syntax_only
= 1;
1068 if (opts
->x_flag_tm
&& opts
->x_flag_non_call_exceptions
)
1069 sorry ("transactional memory is not supported with non-call exceptions");
1071 /* Unless the user has asked for section anchors, we disable toplevel
1072 reordering at -O0 to disable transformations that might be surprising
1073 to end users and to get -fno-toplevel-reorder tested. */
1074 if (!opts
->x_optimize
1075 && opts
->x_flag_toplevel_reorder
== 2
1076 && !(opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
))
1078 opts
->x_flag_toplevel_reorder
= 0;
1079 opts
->x_flag_section_anchors
= 0;
1081 if (!opts
->x_flag_toplevel_reorder
)
1083 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
1084 error_at (loc
, "section anchors must be disabled when toplevel reorder"
1086 opts
->x_flag_section_anchors
= 0;
1089 if (!opts
->x_flag_opts_finished
)
1091 /* We initialize opts->x_flag_pie to -1 so that targets can set a
1093 if (opts
->x_flag_pie
== -1)
1095 /* We initialize opts->x_flag_pic to -1 so that we can tell if
1096 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
1097 if (opts
->x_flag_pic
== -1)
1098 opts
->x_flag_pie
= DEFAULT_FLAG_PIE
;
1100 opts
->x_flag_pie
= 0;
1102 /* If -fPIE or -fpie is used, turn on PIC. */
1103 if (opts
->x_flag_pie
)
1104 opts
->x_flag_pic
= opts
->x_flag_pie
;
1105 else if (opts
->x_flag_pic
== -1)
1106 opts
->x_flag_pic
= 0;
1107 if (opts
->x_flag_pic
&& !opts
->x_flag_pie
)
1108 opts
->x_flag_shlib
= 1;
1109 opts
->x_flag_opts_finished
= true;
1112 /* We initialize opts->x_flag_stack_protect to -1 so that targets
1113 can set a default value. */
1114 if (opts
->x_flag_stack_protect
== -1)
1115 opts
->x_flag_stack_protect
= DEFAULT_FLAG_SSP
;
1117 if (opts
->x_optimize
== 0)
1119 /* Inlining does not work if not optimizing,
1120 so force it not to be done. */
1121 opts
->x_warn_inline
= 0;
1122 opts
->x_flag_no_inline
= 1;
1125 /* Pipelining of outer loops is only possible when general pipelining
1126 capabilities are requested. */
1127 if (!opts
->x_flag_sel_sched_pipelining
)
1128 opts
->x_flag_sel_sched_pipelining_outer_loops
= 0;
1130 if (opts
->x_flag_conserve_stack
)
1132 SET_OPTION_IF_UNSET (opts
, opts_set
, param_large_stack_frame
, 100);
1133 SET_OPTION_IF_UNSET (opts
, opts_set
, param_stack_frame_growth
, 40);
1136 if (opts
->x_flag_lto
)
1139 opts
->x_flag_generate_lto
= 1;
1141 /* When generating IL, do not operate in whole-program mode.
1142 Otherwise, symbols will be privatized too early, causing link
1144 opts
->x_flag_whole_program
= 0;
1146 error_at (loc
, "LTO support has not been enabled in this configuration");
1148 if (!opts
->x_flag_fat_lto_objects
1149 && (!HAVE_LTO_PLUGIN
1150 || (opts_set
->x_flag_use_linker_plugin
1151 && !opts
->x_flag_use_linker_plugin
)))
1153 if (opts_set
->x_flag_fat_lto_objects
)
1154 error_at (loc
, "%<-fno-fat-lto-objects%> are supported only with "
1156 opts
->x_flag_fat_lto_objects
= 1;
1159 /* -gsplit-dwarf isn't compatible with LTO, see PR88389. */
1160 if (opts
->x_dwarf_split_debug_info
)
1162 inform (loc
, "%<-gsplit-dwarf%> is not supported with LTO,"
1164 opts
->x_dwarf_split_debug_info
= 0;
1168 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
1169 default value if they choose based on other options. */
1170 if (opts
->x_flag_split_stack
== -1)
1171 opts
->x_flag_split_stack
= 0;
1172 else if (opts
->x_flag_split_stack
)
1174 if (!targetm_common
.supports_split_stack (true, opts
))
1176 error_at (loc
, "%<-fsplit-stack%> is not supported by "
1177 "this compiler configuration");
1178 opts
->x_flag_split_stack
= 0;
1182 /* If stack splitting is turned on, and the user did not explicitly
1183 request function partitioning, turn off partitioning, as it
1184 confuses the linker when trying to handle partitioned split-stack
1185 code that calls a non-split-stack functions. But if partitioning
1186 was turned on explicitly just hope for the best. */
1187 if (opts
->x_flag_split_stack
1188 && opts
->x_flag_reorder_blocks_and_partition
)
1189 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_reorder_blocks_and_partition
, 0);
1191 if (opts
->x_flag_reorder_blocks_and_partition
)
1192 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_reorder_functions
, 1);
1194 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
1195 if (opts
->x_dwarf_split_debug_info
)
1196 opts
->x_debug_generate_pub_sections
= 2;
1198 if ((opts
->x_flag_sanitize
1199 & (SANITIZE_USER_ADDRESS
| SANITIZE_KERNEL_ADDRESS
)) == 0)
1201 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_COMPARE
)
1203 "%<-fsanitize=pointer-compare%> must be combined with "
1204 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1205 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_SUBTRACT
)
1207 "%<-fsanitize=pointer-subtract%> must be combined with "
1208 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1211 /* Address sanitizers conflict with the thread sanitizer. */
1212 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_THREAD
,
1213 SANITIZE_ADDRESS
| SANITIZE_HWADDRESS
);
1214 /* The leak sanitizer conflicts with the thread sanitizer. */
1215 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_LEAK
,
1218 /* No combination of HWASAN and ASAN work together. */
1219 report_conflicting_sanitizer_options (opts
, loc
,
1220 SANITIZE_HWADDRESS
, SANITIZE_ADDRESS
);
1222 /* The userspace and kernel address sanitizers conflict with each other. */
1223 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_USER_HWADDRESS
,
1224 SANITIZE_KERNEL_HWADDRESS
);
1225 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_USER_ADDRESS
,
1226 SANITIZE_KERNEL_ADDRESS
);
1228 /* Check error recovery for -fsanitize-recover option. */
1229 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1230 if ((opts
->x_flag_sanitize_recover
& sanitizer_opts
[i
].flag
)
1231 && !sanitizer_opts
[i
].can_recover
)
1232 error_at (loc
, "%<-fsanitize-recover=%s%> is not supported",
1233 sanitizer_opts
[i
].name
);
1235 /* When instrumenting the pointers, we don't want to remove
1236 the null pointer checks. */
1237 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
1238 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
1239 opts
->x_flag_delete_null_pointer_checks
= 0;
1241 /* Aggressive compiler optimizations may cause false negatives. */
1242 if (opts
->x_flag_sanitize
& ~(SANITIZE_LEAK
| SANITIZE_UNREACHABLE
))
1243 opts
->x_flag_aggressive_loop_optimizations
= 0;
1245 /* Enable -fsanitize-address-use-after-scope if either address sanitizer is
1247 if (opts
->x_flag_sanitize
1248 & (SANITIZE_USER_ADDRESS
| SANITIZE_USER_HWADDRESS
))
1249 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_sanitize_address_use_after_scope
,
1252 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1254 if (opts
->x_flag_sanitize_address_use_after_scope
)
1256 if (opts
->x_flag_stack_reuse
!= SR_NONE
1257 && opts_set
->x_flag_stack_reuse
!= SR_NONE
)
1259 "%<-fsanitize-address-use-after-scope%> requires "
1260 "%<-fstack-reuse=none%> option");
1262 opts
->x_flag_stack_reuse
= SR_NONE
;
1265 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
) && opts
->x_flag_tm
)
1266 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1268 if ((opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) && opts
->x_flag_tm
)
1269 sorry ("transactional memory is not supported with "
1270 "%<-fsanitize=kernel-address%>");
1272 /* Currently live patching is not support for LTO. */
1273 if (opts
->x_flag_live_patching
&& opts
->x_flag_lto
)
1274 sorry ("live patching is not supported with LTO");
1276 /* Currently vtable verification is not supported for LTO */
1277 if (opts
->x_flag_vtable_verify
&& opts
->x_flag_lto
)
1278 sorry ("vtable verification is not supported with LTO");
1280 /* Control IPA optimizations based on different -flive-patching level. */
1281 if (opts
->x_flag_live_patching
)
1282 control_options_for_live_patching (opts
, opts_set
,
1283 opts
->x_flag_live_patching
,
1286 /* Allow cunroll to grow size accordingly. */
1287 if (!opts_set
->x_flag_cunroll_grow_size
)
1288 opts
->x_flag_cunroll_grow_size
1289 = (opts
->x_flag_unroll_loops
1290 || opts
->x_flag_peel_loops
1291 || opts
->x_optimize
>= 3);
1293 /* With -fcx-limited-range, we do cheap and quick complex arithmetic. */
1294 if (opts
->x_flag_cx_limited_range
)
1295 opts
->x_flag_complex_method
= 0;
1296 else if (opts_set
->x_flag_cx_limited_range
)
1297 opts
->x_flag_complex_method
= opts
->x_flag_default_complex_method
;
1299 /* With -fcx-fortran-rules, we do something in-between cheap and C99. */
1300 if (opts
->x_flag_cx_fortran_rules
)
1301 opts
->x_flag_complex_method
= 1;
1302 else if (opts_set
->x_flag_cx_fortran_rules
)
1303 opts
->x_flag_complex_method
= opts
->x_flag_default_complex_method
;
1305 /* Use -fvect-cost-model=cheap instead of -fvect-cost-mode=very-cheap
1306 by default with explicit -ftree-{loop,slp}-vectorize. */
1307 if (opts
->x_optimize
== 2
1308 && (opts_set
->x_flag_tree_loop_vectorize
1309 || opts_set
->x_flag_tree_vectorize
))
1310 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_vect_cost_model
,
1311 VECT_COST_MODEL_CHEAP
);
1313 if (opts
->x_flag_gtoggle
)
1315 /* Make sure to process -gtoggle only once. */
1316 opts
->x_flag_gtoggle
= false;
1317 if (opts
->x_debug_info_level
== DINFO_LEVEL_NONE
)
1319 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
1321 if (opts
->x_write_symbols
== NO_DEBUG
)
1322 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
1325 opts
->x_debug_info_level
= DINFO_LEVEL_NONE
;
1328 if (!opts_set
->x_debug_nonbind_markers_p
)
1329 opts
->x_debug_nonbind_markers_p
1331 && opts
->x_debug_info_level
>= DINFO_LEVEL_NORMAL
1332 && dwarf_debuginfo_p (opts
)
1333 && !(opts
->x_flag_selective_scheduling
1334 || opts
->x_flag_selective_scheduling2
));
1336 /* We know which debug output will be used so we can set flag_var_tracking
1337 and flag_var_tracking_uninit if the user has not specified them. */
1338 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
1339 || !dwarf_debuginfo_p (opts
)
1340 /* We have not yet initialized debug hooks so match that to check
1341 whether we're only doing DWARF2_LINENO_DEBUGGING_INFO. */
1342 #ifndef DWARF2_DEBUGGING_INFO
1347 if ((opts_set
->x_flag_var_tracking
&& opts
->x_flag_var_tracking
== 1)
1348 || (opts_set
->x_flag_var_tracking_uninit
1349 && opts
->x_flag_var_tracking_uninit
== 1))
1351 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
1352 warning_at (UNKNOWN_LOCATION
, 0,
1353 "variable tracking requested, but useless unless "
1354 "producing debug info");
1356 warning_at (UNKNOWN_LOCATION
, 0,
1357 "variable tracking requested, but not supported "
1358 "by this debug format");
1360 opts
->x_flag_var_tracking
= 0;
1361 opts
->x_flag_var_tracking_uninit
= 0;
1364 /* One could use EnabledBy, but it would lead to a circular dependency. */
1365 if (!opts_set
->x_flag_var_tracking_uninit
)
1366 opts
->x_flag_var_tracking_uninit
= opts
->x_flag_var_tracking
;
1368 if (!opts_set
->x_flag_var_tracking_assignments
)
1369 opts
->x_flag_var_tracking_assignments
1370 = (opts
->x_flag_var_tracking
1371 && !(opts
->x_flag_selective_scheduling
1372 || opts
->x_flag_selective_scheduling2
));
1374 if (opts
->x_flag_var_tracking_assignments_toggle
)
1375 opts
->x_flag_var_tracking_assignments
1376 = !opts
->x_flag_var_tracking_assignments
;
1378 if (opts
->x_flag_var_tracking_assignments
&& !opts
->x_flag_var_tracking
)
1379 opts
->x_flag_var_tracking
= opts
->x_flag_var_tracking_assignments
= -1;
1381 if (opts
->x_flag_var_tracking_assignments
1382 && (opts
->x_flag_selective_scheduling
1383 || opts
->x_flag_selective_scheduling2
))
1385 "var-tracking-assignments changes selective scheduling");
1387 if (opts
->x_flag_syntax_only
)
1389 opts
->x_write_symbols
= NO_DEBUG
;
1390 opts
->x_profile_flag
= 0;
1394 diagnose_options (opts
, opts_set
, loc
);
1397 /* The function diagnoses incompatible combinations for provided options
1398 (OPTS and OPTS_SET) at a given LOCation. The function is called both
1399 when command line is parsed (after the target optimization hook) and
1400 when an optimize/target attribute (or pragma) is used. */
1402 void diagnose_options (gcc_options
*opts
, gcc_options
*opts_set
,
1405 /* The optimization to partition hot and cold basic blocks into separate
1406 sections of the .o and executable files does not work (currently)
1407 with exception handling. This is because there is no support for
1408 generating unwind info. If opts->x_flag_exceptions is turned on
1409 we need to turn off the partitioning optimization. */
1411 enum unwind_info_type ui_except
1412 = targetm_common
.except_unwind_info (opts
);
1414 if (opts
->x_flag_exceptions
1415 && opts
->x_flag_reorder_blocks_and_partition
1416 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1418 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1420 "%<-freorder-blocks-and-partition%> does not work "
1421 "with exceptions on this architecture");
1422 opts
->x_flag_reorder_blocks_and_partition
= 0;
1423 opts
->x_flag_reorder_blocks
= 1;
1426 /* If user requested unwind info, then turn off the partitioning
1429 if (opts
->x_flag_unwind_tables
1430 && !targetm_common
.unwind_tables_default
1431 && opts
->x_flag_reorder_blocks_and_partition
1432 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1434 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1436 "%<-freorder-blocks-and-partition%> does not support "
1437 "unwind info on this architecture");
1438 opts
->x_flag_reorder_blocks_and_partition
= 0;
1439 opts
->x_flag_reorder_blocks
= 1;
1442 /* If the target requested unwind info, then turn off the partitioning
1443 optimization with a different message. Likewise, if the target does not
1444 support named sections. */
1446 if (opts
->x_flag_reorder_blocks_and_partition
1447 && (!targetm_common
.have_named_sections
1448 || (opts
->x_flag_unwind_tables
1449 && targetm_common
.unwind_tables_default
1450 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
1452 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1454 "%<-freorder-blocks-and-partition%> does not work "
1455 "on this architecture");
1456 opts
->x_flag_reorder_blocks_and_partition
= 0;
1457 opts
->x_flag_reorder_blocks
= 1;
1463 #define LEFT_COLUMN 27
1465 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1466 followed by word-wrapped HELP in a second column. */
1468 wrap_help (const char *help
,
1470 unsigned int item_width
,
1471 unsigned int columns
)
1473 unsigned int col_width
= LEFT_COLUMN
;
1474 unsigned int remaining
, room
, len
;
1476 remaining
= strlen (help
);
1480 room
= columns
- 3 - MAX (col_width
, item_width
);
1489 for (i
= 0; help
[i
]; i
++)
1491 if (i
>= room
&& len
!= remaining
)
1495 else if ((help
[i
] == '-' || help
[i
] == '/')
1496 && help
[i
+ 1] != ' '
1497 && i
> 0 && ISALPHA (help
[i
- 1]))
1502 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1504 while (help
[len
] == ' ')
1512 /* Data structure used to print list of valid option values. */
1514 class option_help_tuple
1517 option_help_tuple (int code
, vec
<const char *> values
):
1518 m_code (code
), m_values (values
)
1521 /* Code of an option. */
1524 /* List of possible values. */
1525 vec
<const char *> m_values
;
1528 /* Print help for a specific front-end, etc. */
1530 print_filtered_help (unsigned int include_flags
,
1531 unsigned int exclude_flags
,
1532 unsigned int any_flags
,
1533 unsigned int columns
,
1534 struct gcc_options
*opts
,
1535 unsigned int lang_mask
)
1540 bool displayed
= false;
1543 if (!opts
->x_help_printed
)
1544 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1546 if (!opts
->x_help_enum_printed
)
1547 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1549 auto_vec
<option_help_tuple
> help_tuples
;
1551 for (i
= 0; i
< cl_options_count
; i
++)
1553 const struct cl_option
*option
= cl_options
+ i
;
1558 if (include_flags
== 0
1559 || ((option
->flags
& include_flags
) != include_flags
))
1561 if ((option
->flags
& any_flags
) == 0)
1565 /* Skip unwanted switches. */
1566 if ((option
->flags
& exclude_flags
) != 0)
1569 /* The driver currently prints its own help text. */
1570 if ((option
->flags
& CL_DRIVER
) != 0
1571 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1572 | CL_COMMON
| CL_TARGET
)) == 0)
1575 /* If an option contains a language specification,
1576 exclude it from common unless all languages are present. */
1577 if ((include_flags
& CL_COMMON
)
1578 && !(option
->flags
& CL_DRIVER
)
1579 && (option
->flags
& CL_LANG_ALL
)
1580 && (option
->flags
& CL_LANG_ALL
) != CL_LANG_ALL
)
1584 /* Skip switches that have already been printed. */
1585 if (opts
->x_help_printed
[i
])
1588 opts
->x_help_printed
[i
] = true;
1590 help
= option
->help
;
1593 if (exclude_flags
& CL_UNDOCUMENTED
)
1596 help
= undocumented_msg
;
1599 /* Get the translation. */
1602 if (option
->alias_target
< N_OPTS
1603 && cl_options
[option
->alias_target
].help
)
1605 const struct cl_option
*target
= cl_options
+ option
->alias_target
;
1606 if (option
->help
== NULL
)
1608 /* The option is undocumented but is an alias for an option that
1609 is documented. If the option has alias arguments, then its
1610 purpose is to provide certain arguments to the other option, so
1611 inform the reader of this. Otherwise, point the reader to the
1612 other option in preference to the former. */
1614 if (option
->alias_arg
)
1616 if (option
->neg_alias_arg
)
1617 snprintf (new_help
, sizeof new_help
,
1618 _("Same as %s%s (or, in negated form, %s%s)."),
1619 target
->opt_text
, option
->alias_arg
,
1620 target
->opt_text
, option
->neg_alias_arg
);
1622 snprintf (new_help
, sizeof new_help
,
1624 target
->opt_text
, option
->alias_arg
);
1627 snprintf (new_help
, sizeof new_help
,
1633 /* For documented options with aliases, mention the aliased
1634 option's name for reference. */
1635 snprintf (new_help
, sizeof new_help
,
1636 _("%s Same as %s."),
1637 help
, cl_options
[option
->alias_target
].opt_text
);
1643 if (option
->warn_message
)
1645 /* Mention that the use of the option will trigger a warning. */
1646 if (help
== new_help
)
1647 snprintf (new_help
+ strlen (new_help
),
1648 sizeof new_help
- strlen (new_help
),
1649 " %s", _(use_diagnosed_msg
));
1651 snprintf (new_help
, sizeof new_help
,
1652 "%s %s", help
, _(use_diagnosed_msg
));
1657 /* Find the gap between the name of the
1658 option and its descriptive text. */
1659 tab
= strchr (help
, '\t');
1668 opt
= option
->opt_text
;
1672 /* With the -Q option enabled we change the descriptive text associated
1673 with an option to be an indication of its current setting. */
1674 if (!opts
->x_quiet_flag
)
1676 void *flag_var
= option_flag_var (i
, opts
);
1678 if (len
< (LEFT_COLUMN
+ 2))
1679 strcpy (new_help
, "\t\t");
1681 strcpy (new_help
, "\t");
1683 /* Set to print whether the option is enabled or disabled,
1684 or, if it's an alias for another option, the name of
1685 the aliased option. */
1686 bool print_state
= false;
1688 if (flag_var
!= NULL
1689 && option
->var_type
!= CLVC_DEFER
)
1691 /* If OPTION is only available for a specific subset
1692 of languages other than this one, mention them. */
1693 bool avail_for_lang
= true;
1694 if (unsigned langset
= option
->flags
& CL_LANG_ALL
)
1696 if (!(langset
& lang_mask
))
1698 avail_for_lang
= false;
1699 strcat (new_help
, _("[available in "));
1700 for (unsigned i
= 0, n
= 0; (1U << i
) < CL_LANG_ALL
; ++i
)
1701 if (langset
& (1U << i
))
1704 strcat (new_help
, ", ");
1705 strcat (new_help
, lang_names
[i
]);
1707 strcat (new_help
, "]");
1710 if (!avail_for_lang
)
1711 ; /* Print nothing else if the option is not available
1712 in the current language. */
1713 else if (option
->flags
& CL_JOINED
)
1715 if (option
->var_type
== CLVC_STRING
)
1717 if (* (const char **) flag_var
!= NULL
)
1718 snprintf (new_help
+ strlen (new_help
),
1719 sizeof (new_help
) - strlen (new_help
),
1720 "%s", * (const char **) flag_var
);
1722 else if (option
->var_type
== CLVC_ENUM
)
1724 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1726 const char *arg
= NULL
;
1728 value
= e
->get (flag_var
);
1729 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1731 arg
= _("[default]");
1732 snprintf (new_help
+ strlen (new_help
),
1733 sizeof (new_help
) - strlen (new_help
),
1738 if (option
->cl_host_wide_int
)
1739 sprintf (new_help
+ strlen (new_help
),
1740 _("%llu bytes"), (unsigned long long)
1741 *(unsigned HOST_WIDE_INT
*) flag_var
);
1743 sprintf (new_help
+ strlen (new_help
),
1744 "%i", * (int *) flag_var
);
1751 /* When there is no argument, print the option state only
1752 if the option takes no argument. */
1753 print_state
= !(option
->flags
& CL_JOINED
);
1757 if (option
->alias_target
< N_OPTS
1758 && option
->alias_target
!= OPT_SPECIAL_warn_removed
1759 && option
->alias_target
!= OPT_SPECIAL_ignore
1760 && option
->alias_target
!= OPT_SPECIAL_input_file
1761 && option
->alias_target
!= OPT_SPECIAL_program_name
1762 && option
->alias_target
!= OPT_SPECIAL_unknown
)
1764 const struct cl_option
*target
1765 = &cl_options
[option
->alias_target
];
1766 sprintf (new_help
+ strlen (new_help
), "%s%s",
1768 option
->alias_arg
? option
->alias_arg
: "");
1770 else if (option
->alias_target
== OPT_SPECIAL_ignore
)
1771 strcat (new_help
, ("[ignored]"));
1774 /* Print the state for an on/off option. */
1775 int ena
= option_enabled (i
, lang_mask
, opts
);
1777 strcat (new_help
, _("[enabled]"));
1779 strcat (new_help
, _("[disabled]"));
1786 if (option
->range_max
!= -1)
1789 snprintf (b
, sizeof (b
), "<%d,%d>", option
->range_min
,
1791 opt
= concat (opt
, b
, NULL
);
1795 wrap_help (help
, opt
, len
, columns
);
1798 if (option
->var_type
== CLVC_ENUM
1799 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1800 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1803 vec
<const char *> option_values
1804 = targetm_common
.get_valid_option_values (i
, NULL
);
1805 if (!option_values
.is_empty ())
1806 help_tuples
.safe_push (option_help_tuple (i
, option_values
));
1812 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1815 printf (_(" No options with the desired characteristics were found\n"));
1820 /* PR 31349: Tell the user how to see all of the
1821 options supported by a specific front end. */
1822 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1823 if ((1U << i
) & langs
)
1824 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1825 lang_names
[i
], lang_names
[i
]);
1829 else if (! displayed
)
1830 printf (_(" All options with the desired characteristics have already been displayed\n"));
1834 /* Print details of enumerated option arguments, if those
1835 enumerations have help text headings provided. If no help text
1836 is provided, presume that the possible values are listed in the
1837 help text for the relevant options. */
1838 for (i
= 0; i
< cl_enums_count
; i
++)
1840 unsigned int j
, pos
;
1842 if (opts
->x_help_enum_printed
[i
] != 1)
1844 if (cl_enums
[i
].help
== NULL
)
1846 printf (" %s\n ", _(cl_enums
[i
].help
));
1848 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1850 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1852 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1854 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1864 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1869 opts
->x_help_enum_printed
[i
] = 2;
1872 for (unsigned i
= 0; i
< help_tuples
.length (); i
++)
1874 const struct cl_option
*option
= cl_options
+ help_tuples
[i
].m_code
;
1875 printf (_(" Known valid arguments for %s option:\n "),
1877 for (unsigned j
= 0; j
< help_tuples
[i
].m_values
.length (); j
++)
1878 printf (" %s", help_tuples
[i
].m_values
[j
]);
1883 /* Display help for a specified type of option.
1884 The options must have ALL of the INCLUDE_FLAGS set
1885 ANY of the flags in the ANY_FLAGS set
1886 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1887 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1889 print_specific_help (unsigned int include_flags
,
1890 unsigned int exclude_flags
,
1891 unsigned int any_flags
,
1892 struct gcc_options
*opts
,
1893 unsigned int lang_mask
)
1895 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1896 const char * description
= NULL
;
1897 const char * descrip_extra
= "";
1901 /* Sanity check: Make sure that we do not have more
1902 languages than we have bits available to enumerate them. */
1903 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1905 /* If we have not done so already, obtain
1906 the desired maximum width of the output. */
1907 if (opts
->x_help_columns
== 0)
1909 opts
->x_help_columns
= get_terminal_width ();
1910 if (opts
->x_help_columns
== INT_MAX
)
1911 /* Use a reasonable default. */
1912 opts
->x_help_columns
= 80;
1915 /* Decide upon the title for the options that we are going to display. */
1916 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1918 switch (flag
& include_flags
)
1925 description
= _("The following options are target specific");
1928 description
= _("The following options control compiler warning messages");
1930 case CL_OPTIMIZATION
:
1931 description
= _("The following options control optimizations");
1934 description
= _("The following options are language-independent");
1937 description
= _("The following options control parameters");
1940 if (i
>= cl_lang_count
)
1942 if (exclude_flags
& all_langs_mask
)
1943 description
= _("The following options are specific to just the language ");
1945 description
= _("The following options are supported by the language ");
1946 descrip_extra
= lang_names
[i
];
1951 if (description
== NULL
)
1955 if (include_flags
& CL_UNDOCUMENTED
)
1956 description
= _("The following options are not documented");
1957 else if (include_flags
& CL_SEPARATE
)
1958 description
= _("The following options take separate arguments");
1959 else if (include_flags
& CL_JOINED
)
1960 description
= _("The following options take joined arguments");
1963 internal_error ("unrecognized %<include_flags 0x%x%> passed "
1964 "to %<print_specific_help%>",
1971 if (any_flags
& all_langs_mask
)
1972 description
= _("The following options are language-related");
1974 description
= _("The following options are language-independent");
1978 printf ("%s%s:\n", description
, descrip_extra
);
1979 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
1980 opts
->x_help_columns
, opts
, lang_mask
);
1983 /* Enable FDO-related flags. */
1986 enable_fdo_optimizations (struct gcc_options
*opts
,
1987 struct gcc_options
*opts_set
,
1990 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_branch_probabilities
, value
);
1991 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
1992 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_loops
, value
);
1993 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_peel_loops
, value
);
1994 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tracer
, value
);
1995 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_value_profile_transformations
,
1997 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
1998 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp
, value
);
2001 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp_clone
, 1);
2002 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, 1);
2004 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_predictive_commoning
, value
);
2005 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_split_loops
, value
);
2006 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unswitch_loops
, value
);
2007 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_gcse_after_reload
, value
);
2008 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_vectorize
, value
);
2009 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_slp_vectorize
, value
);
2010 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_version_loops_for_strides
, value
);
2011 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_vect_cost_model
,
2012 VECT_COST_MODEL_DYNAMIC
);
2013 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribute_patterns
,
2015 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_loop_interchange
, value
);
2016 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_jam
, value
);
2017 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribution
, value
);
2020 /* -f{,no-}sanitize{,-recover}= suboptions. */
2021 const struct sanitizer_opts_s sanitizer_opts
[] =
2023 #define SANITIZER_OPT(name, flags, recover) \
2024 { #name, flags, sizeof #name - 1, recover }
2025 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true),
2026 SANITIZER_OPT (hwaddress
, (SANITIZE_HWADDRESS
| SANITIZE_USER_HWADDRESS
),
2028 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
2030 SANITIZER_OPT (kernel
-hwaddress
,
2031 (SANITIZE_HWADDRESS
| SANITIZE_KERNEL_HWADDRESS
),
2033 SANITIZER_OPT (pointer
-compare
, SANITIZE_POINTER_COMPARE
, true),
2034 SANITIZER_OPT (pointer
-subtract
, SANITIZE_POINTER_SUBTRACT
, true),
2035 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false),
2036 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false),
2037 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true),
2038 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true),
2039 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true),
2040 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true),
2041 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true),
2042 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false),
2043 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true),
2044 SANITIZER_OPT (return, SANITIZE_RETURN
, false),
2045 SANITIZER_OPT (null
, SANITIZE_NULL
, true),
2046 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true),
2047 SANITIZER_OPT (bool, SANITIZE_BOOL
, true),
2048 SANITIZER_OPT (enum, SANITIZE_ENUM
, true),
2049 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true),
2050 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true),
2051 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true),
2052 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true),
2053 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true),
2054 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true),
2055 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
2057 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true),
2058 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true),
2059 SANITIZER_OPT (pointer
-overflow
, SANITIZE_POINTER_OVERFLOW
, true),
2060 SANITIZER_OPT (builtin
, SANITIZE_BUILTIN
, true),
2061 SANITIZER_OPT (shadow
-call
-stack
, SANITIZE_SHADOW_CALL_STACK
, false),
2062 SANITIZER_OPT (all
, ~0U, true),
2063 #undef SANITIZER_OPT
2064 { NULL
, 0U, 0UL, false }
2067 /* -fzero-call-used-regs= suboptions. */
2068 const struct zero_call_used_regs_opts_s zero_call_used_regs_opts
[] =
2070 #define ZERO_CALL_USED_REGS_OPT(name, flags) \
2072 ZERO_CALL_USED_REGS_OPT (skip
, zero_regs_flags::SKIP
),
2073 ZERO_CALL_USED_REGS_OPT (used
-gpr
-arg
, zero_regs_flags::USED_GPR_ARG
),
2074 ZERO_CALL_USED_REGS_OPT (used
-gpr
, zero_regs_flags::USED_GPR
),
2075 ZERO_CALL_USED_REGS_OPT (used
-arg
, zero_regs_flags::USED_ARG
),
2076 ZERO_CALL_USED_REGS_OPT (used
, zero_regs_flags::USED
),
2077 ZERO_CALL_USED_REGS_OPT (all
-gpr
-arg
, zero_regs_flags::ALL_GPR_ARG
),
2078 ZERO_CALL_USED_REGS_OPT (all
-gpr
, zero_regs_flags::ALL_GPR
),
2079 ZERO_CALL_USED_REGS_OPT (all
-arg
, zero_regs_flags::ALL_ARG
),
2080 ZERO_CALL_USED_REGS_OPT (all
, zero_regs_flags::ALL
),
2081 #undef ZERO_CALL_USED_REGS_OPT
2085 /* A struct for describing a run of chars within a string. */
2087 class string_fragment
2090 string_fragment (const char *start
, size_t len
)
2091 : m_start (start
), m_len (len
) {}
2093 const char *m_start
;
2097 /* Specialization of edit_distance_traits for string_fragment,
2098 for use by get_closest_sanitizer_option. */
2101 struct edit_distance_traits
<const string_fragment
&>
2103 static size_t get_length (const string_fragment
&fragment
)
2105 return fragment
.m_len
;
2108 static const char *get_string (const string_fragment
&fragment
)
2110 return fragment
.m_start
;
2114 /* Given ARG, an unrecognized sanitizer option, return the best
2115 matching sanitizer option, or NULL if there isn't one.
2116 OPTS is array of candidate sanitizer options.
2117 CODE is OPT_fsanitize_ or OPT_fsanitize_recover_.
2118 VALUE is non-zero for the regular form of the option, zero
2119 for the "no-" form (e.g. "-fno-sanitize-recover="). */
2122 get_closest_sanitizer_option (const string_fragment
&arg
,
2123 const struct sanitizer_opts_s
*opts
,
2124 enum opt_code code
, int value
)
2126 best_match
<const string_fragment
&, const char*> bm (arg
);
2127 for (int i
= 0; opts
[i
].name
!= NULL
; ++i
)
2129 /* -fsanitize=all is not valid, so don't offer it. */
2130 if (code
== OPT_fsanitize_
2131 && opts
[i
].flag
== ~0U
2135 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
2136 don't offer the non-recoverable options. */
2137 if (code
== OPT_fsanitize_recover_
2138 && !opts
[i
].can_recover
2142 bm
.consider (opts
[i
].name
);
2144 return bm
.get_best_meaningful_candidate ();
2147 /* Parse comma separated sanitizer suboptions from P for option SCODE,
2148 adjust previous FLAGS and return new ones. If COMPLAIN is false,
2149 don't issue diagnostics. */
2152 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
2153 unsigned int flags
, int value
, bool complain
)
2155 enum opt_code code
= (enum opt_code
) scode
;
2161 const char *comma
= strchr (p
, ',');
2173 /* Check to see if the string matches an option class name. */
2174 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
2175 if (len
== sanitizer_opts
[i
].len
2176 && memcmp (p
, sanitizer_opts
[i
].name
, len
) == 0)
2178 /* Handle both -fsanitize and -fno-sanitize cases. */
2179 if (value
&& sanitizer_opts
[i
].flag
== ~0U)
2181 if (code
== OPT_fsanitize_
)
2184 error_at (loc
, "%<-fsanitize=all%> option is not valid");
2187 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
2188 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
2189 | SANITIZE_SHADOW_CALL_STACK
);
2193 /* Do not enable -fsanitize-recover=unreachable and
2194 -fsanitize-recover=return if -fsanitize-recover=undefined
2196 if (code
== OPT_fsanitize_recover_
2197 && sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
2198 flags
|= (SANITIZE_UNDEFINED
2199 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
2201 flags
|= sanitizer_opts
[i
].flag
;
2204 flags
&= ~sanitizer_opts
[i
].flag
;
2209 if (! found
&& complain
)
2212 = get_closest_sanitizer_option (string_fragment (p
, len
),
2213 sanitizer_opts
, code
, value
);
2216 if (code
== OPT_fsanitize_recover_
)
2217 suffix
= "-recover";
2223 "unrecognized argument to %<-f%ssanitize%s=%> "
2224 "option: %q.*s; did you mean %qs?",
2226 suffix
, (int) len
, p
, hint
);
2229 "unrecognized argument to %<-f%ssanitize%s=%> option: "
2230 "%q.*s", value
? "" : "no-",
2231 suffix
, (int) len
, p
);
2241 /* Parse string values of no_sanitize attribute passed in VALUE.
2242 Values are separated with comma. */
2245 parse_no_sanitize_attribute (char *value
)
2247 unsigned int flags
= 0;
2249 char *q
= strtok (value
, ",");
2253 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
2254 if (strcmp (sanitizer_opts
[i
].name
, q
) == 0)
2256 flags
|= sanitizer_opts
[i
].flag
;
2257 if (sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
2258 flags
|= SANITIZE_UNDEFINED_NONDEFAULT
;
2262 if (sanitizer_opts
[i
].name
== NULL
)
2263 warning (OPT_Wattributes
,
2264 "%qs attribute directive ignored", q
);
2266 q
= strtok (NULL
, ",");
2272 /* Parse -fzero-call-used-regs suboptions from ARG, return the FLAGS. */
2275 parse_zero_call_used_regs_options (const char *arg
)
2277 unsigned int flags
= 0;
2279 /* Check to see if the string matches a sub-option name. */
2280 for (unsigned int i
= 0; zero_call_used_regs_opts
[i
].name
!= NULL
; ++i
)
2281 if (strcmp (arg
, zero_call_used_regs_opts
[i
].name
) == 0)
2283 flags
= zero_call_used_regs_opts
[i
].flag
;
2288 error ("unrecognized argument to %<-fzero-call-used-regs=%>: %qs", arg
);
2293 /* Parse -falign-NAME format for a FLAG value. Return individual
2294 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
2295 set, print error message at LOC location. */
2298 parse_and_check_align_values (const char *flag
,
2300 auto_vec
<unsigned> &result_values
,
2304 char *str
= xstrdup (flag
);
2305 for (char *p
= strtok (str
, ":"); p
; p
= strtok (NULL
, ":"))
2308 int v
= strtol (p
, &end
, 10);
2309 if (*end
!= '\0' || v
< 0)
2312 error_at (loc
, "invalid arguments for %<-falign-%s%> option: %qs",
2318 result_values
.safe_push ((unsigned)v
);
2323 /* Check that we have a correct number of values. */
2324 if (result_values
.is_empty () || result_values
.length () > 4)
2327 error_at (loc
, "invalid number of arguments for %<-falign-%s%> "
2328 "option: %qs", name
, flag
);
2332 for (unsigned i
= 0; i
< result_values
.length (); i
++)
2333 if (result_values
[i
] > MAX_CODE_ALIGN_VALUE
)
2336 error_at (loc
, "%<-falign-%s%> is not between 0 and %d",
2337 name
, MAX_CODE_ALIGN_VALUE
);
2344 /* Check that alignment value FLAG for -falign-NAME is valid at a given
2345 location LOC. OPT_STR points to the stored -falign-NAME=argument and
2346 OPT_FLAG points to the associated -falign-NAME on/off flag. */
2349 check_alignment_argument (location_t loc
, const char *flag
, const char *name
,
2350 int *opt_flag
, const char **opt_str
)
2352 auto_vec
<unsigned> align_result
;
2353 parse_and_check_align_values (flag
, name
, align_result
, true, loc
);
2355 if (align_result
.length() >= 1 && align_result
[0] == 0)
2362 /* Parse argument of -fpatchable-function-entry option ARG and store
2363 corresponding values to PATCH_AREA_SIZE and PATCH_AREA_START.
2364 If REPORT_ERROR is set to true, generate error for a problematic
2365 option arguments. */
2368 parse_and_check_patch_area (const char *arg
, bool report_error
,
2369 HOST_WIDE_INT
*patch_area_size
,
2370 HOST_WIDE_INT
*patch_area_start
)
2372 *patch_area_size
= 0;
2373 *patch_area_start
= 0;
2378 char *patch_area_arg
= xstrdup (arg
);
2379 char *comma
= strchr (patch_area_arg
, ',');
2383 *patch_area_size
= integral_argument (patch_area_arg
);
2384 *patch_area_start
= integral_argument (comma
+ 1);
2387 *patch_area_size
= integral_argument (patch_area_arg
);
2389 if (*patch_area_size
< 0
2390 || *patch_area_size
> USHRT_MAX
2391 || *patch_area_start
< 0
2392 || *patch_area_start
> USHRT_MAX
2393 || *patch_area_size
< *patch_area_start
)
2395 error ("invalid arguments for %<-fpatchable-function-entry%>");
2397 free (patch_area_arg
);
2400 /* Print help when OPT__help_ is set. */
2403 print_help (struct gcc_options
*opts
, unsigned int lang_mask
,
2404 const char *help_option_argument
)
2406 const char *a
= help_option_argument
;
2407 unsigned int include_flags
= 0;
2408 /* Note - by default we include undocumented options when listing
2409 specific classes. If you only want to see documented options
2410 then add ",^undocumented" to the --help= option. E.g.:
2412 --help=target,^undocumented */
2413 unsigned int exclude_flags
= 0;
2415 if (lang_mask
== CL_DRIVER
)
2418 /* Walk along the argument string, parsing each word in turn.
2420 arg = [^]{word}[,{arg}]
2421 word = {optimizers|target|warnings|undocumented|
2422 params|common|<language>} */
2432 { "optimizers", CL_OPTIMIZATION
},
2433 { "target", CL_TARGET
},
2434 { "warnings", CL_WARNING
},
2435 { "undocumented", CL_UNDOCUMENTED
},
2436 { "params", CL_PARAMS
},
2437 { "joined", CL_JOINED
},
2438 { "separate", CL_SEPARATE
},
2439 { "common", CL_COMMON
},
2442 unsigned int *pflags
;
2444 unsigned int lang_flag
, specific_flag
;
2453 error ("missing argument to %qs", "--help=^");
2456 pflags
= &exclude_flags
;
2459 pflags
= &include_flags
;
2461 comma
= strchr (a
, ',');
2472 /* Check to see if the string matches an option class name. */
2473 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
2474 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
2476 specific_flag
= specifics
[i
].flag
;
2480 /* Check to see if the string matches a language name.
2481 Note - we rely upon the alpha-sorted nature of the entries in
2482 the lang_names array, specifically that shorter names appear
2483 before their longer variants. (i.e. C before C++). That way
2484 when we are attempting to match --help=c for example we will
2485 match with C first and not C++. */
2486 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
2487 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
2489 lang_flag
= 1U << i
;
2493 if (specific_flag
!= 0)
2496 *pflags
|= specific_flag
;
2499 /* The option's argument matches both the start of a
2500 language name and the start of an option class name.
2501 We have a special case for when the user has
2502 specified "--help=c", but otherwise we have to issue
2504 if (strncasecmp (a
, "c", len
) == 0)
2505 *pflags
|= lang_flag
;
2508 "%<--help%> argument %q.*s is ambiguous, "
2509 "please be more specific",
2513 else if (lang_flag
!= 0)
2514 *pflags
|= lang_flag
;
2517 "unrecognized argument to %<--help=%> option: %q.*s",
2525 /* We started using PerFunction/Optimization for parameters and
2526 a warning. We should exclude these from optimization options. */
2527 if (include_flags
& CL_OPTIMIZATION
)
2528 exclude_flags
|= CL_WARNING
;
2529 if (!(include_flags
& CL_PARAMS
))
2530 exclude_flags
|= CL_PARAMS
;
2533 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
2537 /* Handle target- and language-independent options. Return zero to
2538 generate an "unknown option" message. Only options that need
2539 extra handling need to be listed here; if you simply want
2540 DECODED->value assigned to a variable, it happens automatically. */
2543 common_handle_option (struct gcc_options
*opts
,
2544 struct gcc_options
*opts_set
,
2545 const struct cl_decoded_option
*decoded
,
2546 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
2548 const struct cl_option_handlers
*handlers
,
2549 diagnostic_context
*dc
,
2550 void (*target_option_override_hook
) (void))
2552 size_t scode
= decoded
->opt_index
;
2553 const char *arg
= decoded
->arg
;
2554 HOST_WIDE_INT value
= decoded
->value
;
2555 enum opt_code code
= (enum opt_code
) scode
;
2557 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
2563 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
2564 unsigned int undoc_mask
;
2567 if (lang_mask
== CL_DRIVER
)
2570 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
2573 target_option_override_hook ();
2574 /* First display any single language specific options. */
2575 for (i
= 0; i
< cl_lang_count
; i
++)
2577 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
2579 /* Next display any multi language specific options. */
2580 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
2581 /* Then display any remaining, non-language options. */
2582 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
2584 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
2585 opts
->x_exit_after_options
= true;
2589 case OPT__target_help
:
2590 if (lang_mask
== CL_DRIVER
)
2593 target_option_override_hook ();
2594 print_specific_help (CL_TARGET
, 0, 0, opts
, lang_mask
);
2595 opts
->x_exit_after_options
= true;
2600 help_option_arguments
.safe_push (arg
);
2601 opts
->x_exit_after_options
= true;
2606 if (lang_mask
== CL_DRIVER
)
2609 opts
->x_exit_after_options
= true;
2612 case OPT__completion_
:
2615 case OPT_fsanitize_
:
2616 opts
->x_flag_sanitize
2617 = parse_sanitizer_options (arg
, loc
, code
,
2618 opts
->x_flag_sanitize
, value
, true);
2620 /* Kernel ASan implies normal ASan but does not yet support
2622 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
2624 SET_OPTION_IF_UNSET (opts
, opts_set
,
2625 param_asan_instrumentation_with_call_threshold
,
2627 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_globals
, 0);
2628 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_stack
, 0);
2629 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_protect_allocas
, 0);
2630 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_use_after_return
, 0);
2632 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_HWADDRESS
)
2634 SET_OPTION_IF_UNSET (opts
, opts_set
,
2635 param_hwasan_instrument_stack
, 0);
2636 SET_OPTION_IF_UNSET (opts
, opts_set
,
2637 param_hwasan_random_frame_tag
, 0);
2638 SET_OPTION_IF_UNSET (opts
, opts_set
,
2639 param_hwasan_instrument_allocas
, 0);
2643 case OPT_fsanitize_recover_
:
2644 opts
->x_flag_sanitize_recover
2645 = parse_sanitizer_options (arg
, loc
, code
,
2646 opts
->x_flag_sanitize_recover
, value
, true);
2649 case OPT_fasan_shadow_offset_
:
2653 case OPT_fsanitize_address_use_after_scope
:
2654 opts
->x_flag_sanitize_address_use_after_scope
= value
;
2657 case OPT_fsanitize_recover
:
2659 opts
->x_flag_sanitize_recover
2660 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)
2661 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2663 opts
->x_flag_sanitize_recover
2664 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2672 /* Currently handled in a prescan. */
2675 case OPT_Wattributes_
:
2676 if (lang_mask
== CL_DRIVER
)
2681 error_at (loc
, "arguments ignored for %<-Wattributes=%>; use "
2682 "%<-Wno-attributes=%> instead");
2685 else if (arg
[strlen (arg
) - 1] == ',')
2687 error_at (loc
, "trailing %<,%> in arguments for "
2688 "%<-Wno-attributes=%>");
2692 add_comma_separated_to_vector (&opts
->x_flag_ignored_attributes
, arg
);
2696 dc
->warning_as_error_requested
= value
;
2700 if (lang_mask
== CL_DRIVER
)
2703 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
2704 opts
, opts_set
, loc
, dc
);
2707 case OPT_Wfatal_errors
:
2708 dc
->fatal_errors
= value
;
2711 case OPT_Wstack_usage_
:
2712 opts
->x_flag_stack_usage_info
= value
!= -1;
2715 case OPT_Wstrict_aliasing
:
2716 set_Wstrict_aliasing (opts
, value
);
2719 case OPT_Wstrict_overflow
:
2720 opts
->x_warn_strict_overflow
= (value
2721 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2725 case OPT_Wsystem_headers
:
2726 dc
->dc_warn_system_headers
= value
;
2730 opts
->x_flag_gen_aux_info
= 1;
2734 decode_d_option (arg
, opts
, loc
, dc
);
2737 case OPT_fcall_used_
:
2738 case OPT_fcall_saved_
:
2746 case OPT_fdebug_prefix_map_
:
2747 case OPT_ffile_prefix_map_
:
2748 case OPT_fprofile_prefix_map_
:
2752 case OPT_fcallgraph_info
:
2753 opts
->x_flag_callgraph_info
= CALLGRAPH_INFO_NAKED
;
2756 case OPT_fcallgraph_info_
:
2759 my_arg
= xstrdup (arg
);
2760 p
= strtok (my_arg
, ",");
2763 if (strcmp (p
, "su") == 0)
2765 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_STACK_USAGE
;
2766 opts
->x_flag_stack_usage_info
= true;
2768 else if (strcmp (p
, "da") == 0)
2769 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_DYNAMIC_ALLOC
;
2772 p
= strtok (NULL
, ",");
2778 case OPT_fdiagnostics_show_location_
:
2779 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2782 case OPT_fdiagnostics_show_caret
:
2783 dc
->show_caret
= value
;
2786 case OPT_fdiagnostics_show_labels
:
2787 dc
->show_labels_p
= value
;
2790 case OPT_fdiagnostics_show_line_numbers
:
2791 dc
->show_line_numbers_p
= value
;
2794 case OPT_fdiagnostics_color_
:
2795 diagnostic_color_init (dc
, value
);
2798 case OPT_fdiagnostics_urls_
:
2799 diagnostic_urls_init (dc
, value
);
2802 case OPT_fdiagnostics_format_
:
2803 diagnostic_output_format_init (dc
,
2804 (enum diagnostics_output_format
)value
);
2807 case OPT_fdiagnostics_parseable_fixits
:
2808 dc
->extra_output_kind
= (value
2809 ? EXTRA_DIAGNOSTIC_OUTPUT_fixits_v1
2810 : EXTRA_DIAGNOSTIC_OUTPUT_none
);
2813 case OPT_fdiagnostics_column_unit_
:
2814 dc
->column_unit
= (enum diagnostics_column_unit
)value
;
2817 case OPT_fdiagnostics_column_origin_
:
2818 dc
->column_origin
= value
;
2821 case OPT_fdiagnostics_escape_format_
:
2822 dc
->escape_format
= (enum diagnostics_escape_format
)value
;
2825 case OPT_fdiagnostics_show_cwe
:
2826 dc
->show_cwe
= value
;
2829 case OPT_fdiagnostics_path_format_
:
2830 dc
->path_format
= (enum diagnostic_path_format
)value
;
2833 case OPT_fdiagnostics_show_path_depths
:
2834 dc
->show_path_depths
= value
;
2837 case OPT_fdiagnostics_show_option
:
2838 dc
->show_option_requested
= value
;
2841 case OPT_fdiagnostics_minimum_margin_width_
:
2842 dc
->min_margin_width
= value
;
2849 case OPT_ffast_math
:
2850 set_fast_math_flags (opts
, value
);
2853 case OPT_funsafe_math_optimizations
:
2854 set_unsafe_math_optimizations_flags (opts
, value
);
2861 case OPT_finline_limit_
:
2862 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_single
,
2864 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_auto
,
2868 case OPT_finstrument_functions_exclude_function_list_
:
2869 add_comma_separated_to_vector
2870 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2873 case OPT_finstrument_functions_exclude_file_list_
:
2874 add_comma_separated_to_vector
2875 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2878 case OPT_fmessage_length_
:
2879 pp_set_line_maximum_length (dc
->printer
, value
);
2880 diagnostic_set_caret_max_width (dc
, value
);
2884 case OPT_fopt_info_
:
2888 case OPT_foffload_options_
:
2892 case OPT_foffload_abi_
:
2893 #ifdef ACCEL_COMPILER
2894 /* Handled in the 'mkoffload's. */
2896 error_at (loc
, "%<-foffload-abi%> option can be specified only for "
2897 "offload compiler");
2901 case OPT_fpack_struct_
:
2902 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2904 "structure alignment must be a small power of two, not %wu",
2907 opts
->x_initial_max_fld_align
= value
;
2911 case OPT_fplugin_arg_
:
2915 case OPT_fprofile_use_
:
2916 opts
->x_profile_data_prefix
= xstrdup (arg
);
2917 opts
->x_flag_profile_use
= true;
2919 /* No break here - do -fprofile-use processing. */
2921 case OPT_fprofile_use
:
2922 enable_fdo_optimizations (opts
, opts_set
, value
);
2923 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_reorder_functions
,
2925 /* Indirect call profiling should do all useful transformations
2926 speculative devirtualization does. */
2927 if (opts
->x_flag_value_profile_transformations
)
2928 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_devirtualize_speculatively
,
2932 case OPT_fauto_profile_
:
2933 opts
->x_auto_profile_file
= xstrdup (arg
);
2934 opts
->x_flag_auto_profile
= true;
2936 /* No break here - do -fauto-profile processing. */
2938 case OPT_fauto_profile
:
2939 enable_fdo_optimizations (opts
, opts_set
, value
);
2940 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_correction
, value
);
2943 case OPT_fprofile_generate_
:
2944 opts
->x_profile_data_prefix
= xstrdup (arg
);
2946 /* No break here - do -fprofile-generate processing. */
2948 case OPT_fprofile_generate
:
2949 SET_OPTION_IF_UNSET (opts
, opts_set
, profile_arc_flag
, value
);
2950 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
2951 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
2952 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, value
);
2955 case OPT_fprofile_info_section
:
2956 opts
->x_profile_info_section
= ".gcov_info";
2959 case OPT_fpatchable_function_entry_
:
2961 HOST_WIDE_INT patch_area_size
, patch_area_start
;
2962 parse_and_check_patch_area (arg
, true, &patch_area_size
,
2967 case OPT_ftree_vectorize
:
2968 /* Automatically sets -ftree-loop-vectorize and
2969 -ftree-slp-vectorize. Nothing more to do here. */
2971 case OPT_fzero_call_used_regs_
:
2972 opts
->x_flag_zero_call_used_regs
2973 = parse_zero_call_used_regs_options (arg
);
2976 case OPT_fshow_column
:
2977 dc
->show_column
= value
;
2980 case OPT_frandom_seed
:
2981 /* The real switch is -fno-random-seed. */
2987 case OPT_frandom_seed_
:
2991 case OPT_fsched_verbose_
:
2992 #ifdef INSN_SCHEDULING
2993 /* Handled with Var in common.opt. */
2999 case OPT_fsched_stalled_insns_
:
3000 opts
->x_flag_sched_stalled_insns
= value
;
3001 if (opts
->x_flag_sched_stalled_insns
== 0)
3002 opts
->x_flag_sched_stalled_insns
= -1;
3005 case OPT_fsched_stalled_insns_dep_
:
3006 opts
->x_flag_sched_stalled_insns_dep
= value
;
3009 case OPT_fstack_check_
:
3010 if (!strcmp (arg
, "no"))
3011 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
3012 else if (!strcmp (arg
, "generic"))
3013 /* This is the old stack checking method. */
3014 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
3015 ? FULL_BUILTIN_STACK_CHECK
3016 : GENERIC_STACK_CHECK
;
3017 else if (!strcmp (arg
, "specific"))
3018 /* This is the new stack checking method. */
3019 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
3020 ? FULL_BUILTIN_STACK_CHECK
3021 : STACK_CHECK_STATIC_BUILTIN
3022 ? STATIC_BUILTIN_STACK_CHECK
3023 : GENERIC_STACK_CHECK
;
3025 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
3028 case OPT_fstack_limit
:
3029 /* The real switch is -fno-stack-limit. */
3035 case OPT_fstack_limit_register_
:
3036 case OPT_fstack_limit_symbol_
:
3040 case OPT_fstack_usage
:
3041 opts
->x_flag_stack_usage
= value
;
3042 opts
->x_flag_stack_usage_info
= value
!= 0;
3046 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
3051 set_debug_level (BTF_DEBUG
, false, arg
, opts
, opts_set
, loc
);
3052 /* set the debug level to level 2, but if already at level 3,
3054 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
3055 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3059 set_debug_level (CTF_DEBUG
, false, arg
, opts
, opts_set
, loc
);
3060 /* CTF generation feeds off DWARF dies. For optimal CTF, switch debug
3061 info level to 2. If off or at level 1, set it to level 2, but if
3062 already at level 3, don't lower it. */
3063 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
3064 && opts
->x_ctf_debug_info_level
> CTFINFO_LEVEL_NONE
)
3065 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3069 if (arg
&& strlen (arg
) != 0)
3071 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
3072 "use %<-gdwarf-%s%> for DWARF version "
3073 "or %<-gdwarf%> %<-g%s%> for debug level", arg
, arg
, arg
);
3077 value
= opts
->x_dwarf_version
;
3081 if (value
< 2 || value
> 5)
3082 error_at (loc
, "dwarf version %wu is not supported", value
);
3084 opts
->x_dwarf_version
= value
;
3085 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
3089 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
3094 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
, opts
, opts_set
,
3099 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
3104 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
, opts
, opts_set
,
3110 /* Handled completely via specs. */
3113 case OPT_pedantic_errors
:
3114 dc
->pedantic_errors
= 1;
3115 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
3117 handlers
, opts
, opts_set
,
3122 opts
->x_flag_lto
= value
? "" : NULL
;
3126 if (strcmp (arg
, "none") != 0
3127 && strcmp (arg
, "jobserver") != 0
3128 && strcmp (arg
, "auto") != 0
3131 "unrecognized argument to %<-flto=%> option: %qs", arg
);
3135 dc
->dc_inhibit_warnings
= true;
3138 case OPT_fmax_errors_
:
3139 dc
->max_errors
= value
;
3142 case OPT_fuse_ld_bfd
:
3143 case OPT_fuse_ld_gold
:
3144 case OPT_fuse_ld_lld
:
3145 case OPT_fuse_ld_mold
:
3146 case OPT_fuse_linker_plugin
:
3147 /* No-op. Used by the driver and passed to us because it starts with f.*/
3152 opts
->x_flag_trapv
= 0;
3157 opts
->x_flag_wrapv
= 0;
3160 case OPT_fstrict_overflow
:
3161 opts
->x_flag_wrapv
= !value
;
3162 opts
->x_flag_wrapv_pointer
= !value
;
3164 opts
->x_flag_trapv
= 0;
3168 opts
->x_flag_ipa_icf_functions
= value
;
3169 opts
->x_flag_ipa_icf_variables
= value
;
3172 case OPT_falign_loops_
:
3173 check_alignment_argument (loc
, arg
, "loops",
3174 &opts
->x_flag_align_loops
,
3175 &opts
->x_str_align_loops
);
3178 case OPT_falign_jumps_
:
3179 check_alignment_argument (loc
, arg
, "jumps",
3180 &opts
->x_flag_align_jumps
,
3181 &opts
->x_str_align_jumps
);
3184 case OPT_falign_labels_
:
3185 check_alignment_argument (loc
, arg
, "labels",
3186 &opts
->x_flag_align_labels
,
3187 &opts
->x_str_align_labels
);
3190 case OPT_falign_functions_
:
3191 check_alignment_argument (loc
, arg
, "functions",
3192 &opts
->x_flag_align_functions
,
3193 &opts
->x_str_align_functions
);
3197 /* It is documented that we silently ignore silly values. */
3198 if (value
>= 1 && value
<= 100)
3199 dc
->tabstop
= value
;
3202 case OPT_freport_bug
:
3203 dc
->report_bug
= value
;
3207 /* If the flag was handled in a standard way, assume the lack of
3208 processing here is intentional. */
3209 gcc_assert (option_flag_var (scode
, opts
));
3213 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
3218 /* Used to set the level of strict aliasing warnings in OPTS,
3219 when no level is specified (i.e., when -Wstrict-aliasing, and not
3220 -Wstrict-aliasing=level was given).
3221 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
3222 and 0 otherwise. After calling this function, wstrict_aliasing will be
3223 set to the default value of -Wstrict_aliasing=level, currently 3. */
3225 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
3227 gcc_assert (onoff
== 0 || onoff
== 1);
3229 opts
->x_warn_strict_aliasing
= 3;
3231 opts
->x_warn_strict_aliasing
= 0;
3234 /* The following routines are useful in setting all the flags that
3235 -ffast-math and -fno-fast-math imply. */
3237 set_fast_math_flags (struct gcc_options
*opts
, int set
)
3239 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
3241 opts
->x_flag_unsafe_math_optimizations
= set
;
3242 set_unsafe_math_optimizations_flags (opts
, set
);
3244 if (!opts
->frontend_set_flag_finite_math_only
)
3245 opts
->x_flag_finite_math_only
= set
;
3246 if (!opts
->frontend_set_flag_errno_math
)
3247 opts
->x_flag_errno_math
= !set
;
3250 if (opts
->frontend_set_flag_excess_precision
== EXCESS_PRECISION_DEFAULT
)
3251 opts
->x_flag_excess_precision
3252 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
3253 if (!opts
->frontend_set_flag_signaling_nans
)
3254 opts
->x_flag_signaling_nans
= 0;
3255 if (!opts
->frontend_set_flag_rounding_math
)
3256 opts
->x_flag_rounding_math
= 0;
3257 if (!opts
->frontend_set_flag_cx_limited_range
)
3258 opts
->x_flag_cx_limited_range
= 1;
3262 /* When -funsafe-math-optimizations is set the following
3263 flags are set as well. */
3265 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
3267 if (!opts
->frontend_set_flag_trapping_math
)
3268 opts
->x_flag_trapping_math
= !set
;
3269 if (!opts
->frontend_set_flag_signed_zeros
)
3270 opts
->x_flag_signed_zeros
= !set
;
3271 if (!opts
->frontend_set_flag_associative_math
)
3272 opts
->x_flag_associative_math
= set
;
3273 if (!opts
->frontend_set_flag_reciprocal_math
)
3274 opts
->x_flag_reciprocal_math
= set
;
3277 /* Return true iff flags in OPTS are set as if -ffast-math. */
3279 fast_math_flags_set_p (const struct gcc_options
*opts
)
3281 return (!opts
->x_flag_trapping_math
3282 && opts
->x_flag_unsafe_math_optimizations
3283 && opts
->x_flag_finite_math_only
3284 && !opts
->x_flag_signed_zeros
3285 && !opts
->x_flag_errno_math
3286 && opts
->x_flag_excess_precision
== EXCESS_PRECISION_FAST
);
3289 /* Return true iff flags are set as if -ffast-math but using the flags stored
3290 in the struct cl_optimization structure. */
3292 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
3294 return (!opt
->x_flag_trapping_math
3295 && opt
->x_flag_unsafe_math_optimizations
3296 && opt
->x_flag_finite_math_only
3297 && !opt
->x_flag_signed_zeros
3298 && !opt
->x_flag_errno_math
);
3301 /* Handle a debug output -g switch for options OPTS
3302 (OPTS_SET->x_write_symbols storing whether a debug format was passed
3303 explicitly), location LOC. EXTENDED is true or false to support
3304 extended output (2 is special and means "-ggdb" was given). */
3306 set_debug_level (uint32_t dinfo
, int extended
, const char *arg
,
3307 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
3310 opts
->x_use_gnu_debug_info_extensions
= extended
;
3312 if (dinfo
== NO_DEBUG
)
3314 if (opts
->x_write_symbols
== NO_DEBUG
)
3316 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
3320 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
3321 if (opts
->x_write_symbols
& CTF_DEBUG
)
3322 opts
->x_write_symbols
|= DWARF2_DEBUG
;
3324 opts
->x_write_symbols
= DWARF2_DEBUG
;
3325 #elif defined DBX_DEBUGGING_INFO
3326 opts
->x_write_symbols
= DBX_DEBUG
;
3330 if (opts
->x_write_symbols
== NO_DEBUG
)
3331 warning_at (loc
, 0, "target system does not support debug output");
3333 else if ((opts
->x_write_symbols
& CTF_DEBUG
)
3334 || (opts
->x_write_symbols
& BTF_DEBUG
))
3336 opts
->x_write_symbols
|= DWARF2_DEBUG
;
3337 opts_set
->x_write_symbols
|= DWARF2_DEBUG
;
3342 /* Make and retain the choice if both CTF and DWARF debug info are to
3344 if (((dinfo
== DWARF2_DEBUG
) || (dinfo
== CTF_DEBUG
))
3345 && ((opts
->x_write_symbols
== (DWARF2_DEBUG
|CTF_DEBUG
))
3346 || (opts
->x_write_symbols
== DWARF2_DEBUG
)
3347 || (opts
->x_write_symbols
== CTF_DEBUG
)))
3349 opts
->x_write_symbols
|= dinfo
;
3350 opts_set
->x_write_symbols
|= dinfo
;
3352 /* However, CTF and BTF are not allowed together at this time. */
3353 else if (((dinfo
== DWARF2_DEBUG
) || (dinfo
== BTF_DEBUG
))
3354 && ((opts
->x_write_symbols
== (DWARF2_DEBUG
|BTF_DEBUG
))
3355 || (opts
->x_write_symbols
== DWARF2_DEBUG
)
3356 || (opts
->x_write_symbols
== BTF_DEBUG
)))
3358 opts
->x_write_symbols
|= dinfo
;
3359 opts_set
->x_write_symbols
|= dinfo
;
3363 /* Does it conflict with an already selected debug format? */
3364 if (opts_set
->x_write_symbols
!= NO_DEBUG
3365 && opts
->x_write_symbols
!= NO_DEBUG
3366 && dinfo
!= opts
->x_write_symbols
)
3368 gcc_assert (debug_set_count (dinfo
) <= 1);
3369 error_at (loc
, "debug format %qs conflicts with prior selection",
3370 debug_type_names
[debug_set_to_format (dinfo
)]);
3372 opts
->x_write_symbols
= dinfo
;
3373 opts_set
->x_write_symbols
= dinfo
;
3377 if (dinfo
!= BTF_DEBUG
)
3379 /* A debug flag without a level defaults to level 2.
3380 If off or at level 1, set it to level 2, but if already
3381 at level 3, don't lower it. */
3384 if (dinfo
== CTF_DEBUG
)
3385 opts
->x_ctf_debug_info_level
= CTFINFO_LEVEL_NORMAL
;
3386 else if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
3387 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3391 int argval
= integral_argument (arg
);
3393 error_at (loc
, "unrecognized debug output level %qs", arg
);
3394 else if (argval
> 3)
3395 error_at (loc
, "debug output level %qs is too high", arg
);
3398 if (dinfo
== CTF_DEBUG
)
3399 opts
->x_ctf_debug_info_level
3400 = (enum ctf_debug_info_levels
) argval
;
3402 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
3406 else if (*arg
!= '\0')
3407 error_at (loc
, "unrecognized btf debug output level %qs", arg
);
3410 /* Arrange to dump core on error for diagnostic context DC. (The
3411 regular error message is still printed first, except in the case of
3415 setup_core_dumping (diagnostic_context
*dc
)
3418 signal (SIGABRT
, SIG_DFL
);
3420 #if defined(HAVE_SETRLIMIT)
3423 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
3424 fatal_error (input_location
, "getting core file size maximum limit: %m");
3425 rlim
.rlim_cur
= rlim
.rlim_max
;
3426 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
3427 fatal_error (input_location
,
3428 "setting core file size limit to maximum: %m");
3431 diagnostic_abort_on_error (dc
);
3434 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
3435 diagnostic context DC. */
3438 decode_d_option (const char *arg
, struct gcc_options
*opts
,
3439 location_t loc
, diagnostic_context
*dc
)
3447 opts
->x_flag_debug_asm
= 1;
3450 opts
->x_flag_print_asm_name
= 1;
3453 opts
->x_flag_dump_rtl_in_asm
= 1;
3454 opts
->x_flag_print_asm_name
= 1;
3457 opts
->x_rtl_dump_and_exit
= 1;
3459 case 'D': /* These are handled by the preprocessor. */
3466 setup_core_dumping (dc
);
3469 opts
->x_flag_dump_all_passed
= true;
3473 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
3478 /* Enable (or disable if VALUE is 0) a warning option ARG (language
3479 mask LANG_MASK, option handlers HANDLERS) as an error for option
3480 structures OPTS and OPTS_SET, diagnostic context DC (possibly
3481 NULL), location LOC. This is used by -Werror=. */
3484 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
3485 const struct cl_option_handlers
*handlers
,
3486 struct gcc_options
*opts
,
3487 struct gcc_options
*opts_set
,
3488 location_t loc
, diagnostic_context
*dc
)
3493 new_option
= XNEWVEC (char, strlen (arg
) + 2);
3494 new_option
[0] = 'W';
3495 strcpy (new_option
+ 1, arg
);
3496 option_index
= find_opt (new_option
, lang_mask
);
3497 if (option_index
== OPT_SPECIAL_unknown
)
3500 const char *hint
= op
.suggest_option (new_option
);
3502 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>;"
3503 " did you mean %<-%s%>?", value
? "" : "no-",
3504 arg
, new_option
, hint
);
3506 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>",
3507 value
? "" : "no-", arg
, new_option
);
3509 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
3510 error_at (loc
, "%<-Werror=%s%>: %<-%s%> is not an option that "
3511 "controls warnings", arg
, new_option
);
3514 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
3515 const char *arg
= NULL
;
3517 if (cl_options
[option_index
].flags
& CL_JOINED
)
3518 arg
= new_option
+ cl_options
[option_index
].opt_len
;
3519 control_warning_option (option_index
, (int) kind
, arg
, value
,
3521 handlers
, opts
, opts_set
, dc
);
3526 /* Return malloced memory for the name of the option OPTION_INDEX
3527 which enabled a diagnostic (context CONTEXT), originally of type
3528 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
3532 option_name (diagnostic_context
*context
, int option_index
,
3533 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
3537 /* A warning classified as an error. */
3538 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
3539 && diag_kind
== DK_ERROR
)
3540 return concat (cl_options
[OPT_Werror_
].opt_text
,
3541 /* Skip over "-W". */
3542 cl_options
[option_index
].opt_text
+ 2,
3544 /* A warning with option. */
3546 return xstrdup (cl_options
[option_index
].opt_text
);
3548 /* A warning without option classified as an error. */
3549 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
3550 || diag_kind
== DK_WARNING
)
3551 && context
->warning_as_error_requested
)
3552 return xstrdup (cl_options
[OPT_Werror
].opt_text
);
3557 /* Get the page within the documentation for this option. */
3560 get_option_html_page (int option_index
)
3562 const cl_option
*cl_opt
= &cl_options
[option_index
];
3564 /* Analyzer options are on their own page. */
3565 if (strstr (cl_opt
->opt_text
, "analyzer-"))
3566 return "gcc/Static-Analyzer-Options.html";
3568 /* Handle -flto= option. */
3569 if (strstr (cl_opt
->opt_text
, "flto"))
3570 return "gcc/Optimize-Options.html";
3573 if ((cl_opt
->flags
& CL_Fortran
) != 0
3574 /* If it is option common to both C/C++ and Fortran, it is documented
3575 in gcc/ rather than gfortran/ docs. */
3576 && (cl_opt
->flags
& CL_C
) == 0
3578 && (cl_opt
->flags
& CL_CXX
) == 0
3581 return "gfortran/Error-and-Warning-Options.html";
3584 return "gcc/Warning-Options.html";
3587 /* Return malloced memory for a URL describing the option OPTION_INDEX
3588 which enabled a diagnostic (context CONTEXT). */
3591 get_option_url (diagnostic_context
*, int option_index
)
3594 return concat (/* DOCUMENTATION_ROOT_URL should be supplied via -D by
3595 the Makefile (see --with-documentation-root-url), and
3596 should have a trailing slash. */
3597 DOCUMENTATION_ROOT_URL
,
3599 /* get_option_html_page will return something like
3600 "gcc/Warning-Options.html". */
3601 get_option_html_page (option_index
),
3603 /* Expect an anchor of the form "index-Wfoo" e.g.
3604 <a name="index-Wformat"></a>, and thus an id within
3605 the URL of "#index-Wformat". */
3606 "#index", cl_options
[option_index
].opt_text
,
3612 /* Return a heap allocated producer with command line options. */
3615 gen_command_line_string (cl_decoded_option
*options
,
3616 unsigned int options_count
)
3618 auto_vec
<const char *> switches
;
3619 char *options_string
, *tail
;
3623 for (unsigned i
= 0; i
< options_count
; i
++)
3624 switch (options
[i
].opt_index
)
3629 case OPT_dumpbase_ext
:
3639 case OPT_SPECIAL_unknown
:
3640 case OPT_SPECIAL_ignore
:
3641 case OPT_SPECIAL_warn_removed
:
3642 case OPT_SPECIAL_program_name
:
3643 case OPT_SPECIAL_input_file
:
3644 case OPT_grecord_gcc_switches
:
3645 case OPT_frecord_gcc_switches
:
3646 case OPT__output_pch
:
3647 case OPT_fdiagnostics_show_location_
:
3648 case OPT_fdiagnostics_show_option
:
3649 case OPT_fdiagnostics_show_caret
:
3650 case OPT_fdiagnostics_show_labels
:
3651 case OPT_fdiagnostics_show_line_numbers
:
3652 case OPT_fdiagnostics_color_
:
3653 case OPT_fdiagnostics_format_
:
3654 case OPT_fverbose_asm
:
3658 case OPT_nostdinc__
:
3659 case OPT_fpreprocessed
:
3660 case OPT_fltrans_output_list_
:
3661 case OPT_fresolution_
:
3662 case OPT_fdebug_prefix_map_
:
3663 case OPT_fmacro_prefix_map_
:
3664 case OPT_ffile_prefix_map_
:
3665 case OPT_fprofile_prefix_map_
:
3666 case OPT_fcompare_debug
:
3668 case OPT_fchecking_
:
3673 const char *lto_canonical
= "-flto";
3674 switches
.safe_push (lto_canonical
);
3675 len
+= strlen (lto_canonical
) + 1;
3679 if (cl_options
[options
[i
].opt_index
].flags
3680 & CL_NO_DWARF_RECORD
)
3682 gcc_checking_assert (options
[i
].canonical_option
[0][0] == '-');
3683 switch (options
[i
].canonical_option
[0][1])
3690 if (strncmp (options
[i
].canonical_option
[0] + 2,
3697 switches
.safe_push (options
[i
].orig_option_with_args_text
);
3698 len
+= strlen (options
[i
].orig_option_with_args_text
) + 1;
3702 options_string
= XNEWVEC (char, len
+ 1);
3703 tail
= options_string
;
3706 FOR_EACH_VEC_ELT (switches
, i
, p
)
3709 memcpy (tail
, p
, len
);
3711 if (i
!= switches
.length () - 1)
3719 return options_string
;
3722 /* Return a heap allocated producer string including command line options. */
3725 gen_producer_string (const char *language_string
, cl_decoded_option
*options
,
3726 unsigned int options_count
)
3728 char *cmdline
= gen_command_line_string (options
, options_count
);
3729 char *combined
= concat (language_string
, " ", version_string
, " ",
3737 namespace selftest
{
3739 /* Verify that get_option_html_page works as expected. */
3742 test_get_option_html_page ()
3744 ASSERT_STREQ (get_option_html_page (OPT_Wcpp
), "gcc/Warning-Options.html");
3745 ASSERT_STREQ (get_option_html_page (OPT_Wanalyzer_double_free
),
3746 "gcc/Static-Analyzer-Options.html");
3748 ASSERT_STREQ (get_option_html_page (OPT_Wline_truncation
),
3749 "gfortran/Error-and-Warning-Options.html");
3753 /* Verify EnumSet and EnumBitSet requirements. */
3758 for (unsigned i
= 0; i
< cl_options_count
; ++i
)
3759 if (cl_options
[i
].var_type
== CLVC_ENUM
3760 && cl_options
[i
].var_value
!= CLEV_NORMAL
)
3762 const struct cl_enum
*e
= &cl_enums
[cl_options
[i
].var_enum
];
3763 unsigned HOST_WIDE_INT used_sets
= 0;
3764 unsigned HOST_WIDE_INT mask
= 0;
3765 unsigned highest_set
= 0;
3766 for (unsigned j
= 0; e
->values
[j
].arg
; ++j
)
3768 unsigned set
= e
->values
[j
].flags
>> CL_ENUM_SET_SHIFT
;
3769 if (cl_options
[i
].var_value
== CLEV_BITSET
)
3771 /* For EnumBitSet Set shouldn't be used and Value should
3772 be a power of two. */
3773 ASSERT_TRUE (set
== 0);
3774 ASSERT_TRUE (pow2p_hwi (e
->values
[j
].value
));
3777 /* Test that enumerators referenced in EnumSet have all
3778 Set(n) on them within the valid range. */
3779 ASSERT_TRUE (set
>= 1 && set
<= HOST_BITS_PER_WIDE_INT
);
3780 highest_set
= MAX (set
, highest_set
);
3781 used_sets
|= HOST_WIDE_INT_1U
<< (set
- 1);
3783 if (cl_options
[i
].var_value
== CLEV_BITSET
)
3785 /* If there is just one set, no point to using EnumSet. */
3786 ASSERT_TRUE (highest_set
>= 2);
3787 /* Test that there are no gaps in between the sets. */
3788 if (highest_set
== HOST_BITS_PER_WIDE_INT
)
3789 ASSERT_TRUE (used_sets
== HOST_WIDE_INT_M1U
);
3791 ASSERT_TRUE (used_sets
== (HOST_WIDE_INT_1U
<< highest_set
) - 1);
3792 for (unsigned int j
= 1; j
<= highest_set
; ++j
)
3794 unsigned HOST_WIDE_INT this_mask
= 0;
3795 for (unsigned k
= 0; e
->values
[k
].arg
; ++k
)
3797 unsigned set
= e
->values
[j
].flags
>> CL_ENUM_SET_SHIFT
;
3799 this_mask
|= e
->values
[j
].value
;
3801 ASSERT_TRUE ((mask
& this_mask
) == 0);
3807 /* Run all of the selftests within this file. */
3812 test_get_option_html_page ();
3816 } // namespace selftest
3818 #endif /* #if CHECKING_P */