1 /* Command line option handling.
2 Copyright (C) 2002-2022 Free Software Foundation, Inc.
3 Contributed by Neil Booth.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
28 #include "diagnostic.h"
29 #include "opts-diagnostic.h"
30 #include "insn-attr-common.h"
31 #include "common/common-target.h"
32 #include "spellcheck.h"
33 #include "opt-suggestions.h"
34 #include "diagnostic-color.h"
38 /* In this file all option sets are explicit. */
41 static void set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
);
43 /* Names of fundamental debug info formats indexed by enum
46 const char *const debug_type_names
[] =
48 "none", "stabs", "dwarf-2", "xcoff", "vms", "ctf", "btf"
51 /* Bitmasks of fundamental debug info formats indexed by enum
54 static uint32_t debug_type_masks
[] =
56 NO_DEBUG
, DWARF2_DEBUG
, VMS_DEBUG
,
60 /* Names of the set of debug formats requested by user. Updated and accessed
61 via debug_set_names. */
63 static char df_set_names
[sizeof "none stabs dwarf-2 xcoff vms ctf btf"];
65 /* Get enum debug_info_type of the specified debug format, for error messages.
66 Can be used only for individual debug format types. */
69 debug_set_to_format (uint32_t debug_info_set
)
72 enum debug_info_type dinfo_type
= DINFO_TYPE_NONE
;
73 /* Find first set bit. */
75 idx
= exact_log2 (debug_info_set
& - debug_info_set
);
76 /* Check that only one bit is set, if at all. This function is meant to be
77 used only for vanilla debug_info_set bitmask values, i.e. for individual
78 debug format types upto DINFO_TYPE_MAX. */
79 gcc_assert ((debug_info_set
& (debug_info_set
- 1)) == 0);
80 dinfo_type
= (enum debug_info_type
)idx
;
81 gcc_assert (dinfo_type
<= DINFO_TYPE_MAX
);
85 /* Get the number of debug formats enabled for output. */
88 debug_set_count (uint32_t w_symbols
)
90 unsigned int count
= 0;
94 w_symbols
&= ~ (w_symbols
& - w_symbols
);
99 /* Get the names of the debug formats enabled for output. */
102 debug_set_names (uint32_t w_symbols
)
104 uint32_t df_mask
= 0;
105 /* Reset the string to be returned. */
106 memset (df_set_names
, 0, sizeof (df_set_names
));
107 /* Get the popcount. */
108 int num_set_df
= debug_set_count (w_symbols
);
109 /* Iterate over the debug formats. Add name string for those enabled. */
110 for (int i
= DINFO_TYPE_NONE
; i
<= DINFO_TYPE_MAX
; i
++)
112 df_mask
= debug_type_masks
[i
];
113 if (w_symbols
& df_mask
)
115 strcat (df_set_names
, debug_type_names
[i
]);
118 strcat (df_set_names
, " ");
124 /* No debug formats enabled. */
125 gcc_assert (i
== DINFO_TYPE_NONE
);
126 strcat (df_set_names
, debug_type_names
[i
]);
133 /* Return TRUE iff BTF debug info is enabled. */
138 return (write_symbols
& BTF_DEBUG
);
141 /* Return TRUE iff BTF with CO-RE debug info is enabled. */
144 btf_with_core_debuginfo_p ()
146 return (write_symbols
& BTF_WITH_CORE_DEBUG
);
149 /* Return TRUE iff CTF debug info is enabled. */
154 return (write_symbols
& CTF_DEBUG
);
157 /* Return TRUE iff dwarf2 debug info is enabled. */
160 dwarf_debuginfo_p (struct gcc_options
*opts
)
162 return (opts
->x_write_symbols
& DWARF2_DEBUG
);
165 /* Return true iff the debug info format is to be generated based on DWARF
166 DIEs (like CTF and BTF debug info formats). */
168 bool dwarf_based_debuginfo_p ()
170 return ((write_symbols
& CTF_DEBUG
)
171 || (write_symbols
& BTF_DEBUG
));
174 /* All flag uses below need to explicitely reference the option sets
176 #define global_options DO_NOT_USE
177 #define global_options_set DO_NOT_USE
179 /* Parse the -femit-struct-debug-detailed option value
180 and set the flag variables. */
182 #define MATCH( prefix, string ) \
183 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
184 ? ((string += sizeof prefix - 1), 1) : 0)
187 set_struct_debug_option (struct gcc_options
*opts
, location_t loc
,
190 /* various labels for comparison */
191 static const char dfn_lbl
[] = "dfn:", dir_lbl
[] = "dir:", ind_lbl
[] = "ind:";
192 static const char ord_lbl
[] = "ord:", gen_lbl
[] = "gen:";
193 static const char none_lbl
[] = "none", any_lbl
[] = "any";
194 static const char base_lbl
[] = "base", sys_lbl
[] = "sys";
196 enum debug_struct_file files
= DINFO_STRUCT_FILE_ANY
;
197 /* Default is to apply to as much as possible. */
198 enum debug_info_usage usage
= DINFO_USAGE_NUM_ENUMS
;
199 int ord
= 1, gen
= 1;
202 if (MATCH (dfn_lbl
, spec
))
203 usage
= DINFO_USAGE_DFN
;
204 else if (MATCH (dir_lbl
, spec
))
205 usage
= DINFO_USAGE_DIR_USE
;
206 else if (MATCH (ind_lbl
, spec
))
207 usage
= DINFO_USAGE_IND_USE
;
209 /* Generics or not? */
210 if (MATCH (ord_lbl
, spec
))
212 else if (MATCH (gen_lbl
, spec
))
215 /* What allowable environment? */
216 if (MATCH (none_lbl
, spec
))
217 files
= DINFO_STRUCT_FILE_NONE
;
218 else if (MATCH (any_lbl
, spec
))
219 files
= DINFO_STRUCT_FILE_ANY
;
220 else if (MATCH (sys_lbl
, spec
))
221 files
= DINFO_STRUCT_FILE_SYS
;
222 else if (MATCH (base_lbl
, spec
))
223 files
= DINFO_STRUCT_FILE_BASE
;
226 "argument %qs to %<-femit-struct-debug-detailed%> "
230 /* Effect the specification. */
231 if (usage
== DINFO_USAGE_NUM_ENUMS
)
235 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DFN
] = files
;
236 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
] = files
;
237 opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
] = files
;
241 opts
->x_debug_struct_generic
[DINFO_USAGE_DFN
] = files
;
242 opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
] = files
;
243 opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
] = files
;
249 opts
->x_debug_struct_ordinary
[usage
] = files
;
251 opts
->x_debug_struct_generic
[usage
] = files
;
255 set_struct_debug_option (opts
, loc
, spec
+1);
258 /* No more -femit-struct-debug-detailed specifications.
262 "argument %qs to %<-femit-struct-debug-detailed%> unknown",
264 if (opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
]
265 < opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
]
266 || opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
]
267 < opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
])
269 "%<-femit-struct-debug-detailed=dir:...%> must allow "
270 "at least as much as "
271 "%<-femit-struct-debug-detailed=ind:...%>");
275 /* Strip off a legitimate source ending from the input string NAME of
276 length LEN. Rather than having to know the names used by all of
277 our front ends, we strip off an ending of a period followed by
278 up to fource characters. (C++ uses ".cpp".) */
281 strip_off_ending (char *name
, int len
)
284 for (i
= 2; i
< 5 && len
> i
; i
++)
286 if (name
[len
- i
] == '.')
288 name
[len
- i
] = '\0';
294 /* Find the base name of a path, stripping off both directories and
295 a single final extension. */
297 base_of_path (const char *path
, const char **base_out
)
299 const char *base
= path
;
301 const char *p
= path
;
305 if (IS_DIR_SEPARATOR (c
))
320 /* What to print when a switch has no documentation. */
321 static const char undocumented_msg
[] = N_("This option lacks documentation.");
322 static const char use_diagnosed_msg
[] = N_("Uses of this option are diagnosed.");
324 typedef char *char_p
; /* For DEF_VEC_P. */
326 static void set_debug_level (uint32_t dinfo
, int extended
,
327 const char *arg
, struct gcc_options
*opts
,
328 struct gcc_options
*opts_set
,
330 static void set_fast_math_flags (struct gcc_options
*opts
, int set
);
331 static void decode_d_option (const char *arg
, struct gcc_options
*opts
,
332 location_t loc
, diagnostic_context
*dc
);
333 static void set_unsafe_math_optimizations_flags (struct gcc_options
*opts
,
335 static void enable_warning_as_error (const char *arg
, int value
,
336 unsigned int lang_mask
,
337 const struct cl_option_handlers
*handlers
,
338 struct gcc_options
*opts
,
339 struct gcc_options
*opts_set
,
341 diagnostic_context
*dc
);
343 /* Handle a back-end option; arguments and return value as for
347 target_handle_option (struct gcc_options
*opts
,
348 struct gcc_options
*opts_set
,
349 const struct cl_decoded_option
*decoded
,
350 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
352 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
353 diagnostic_context
*dc
, void (*) (void))
355 gcc_assert (dc
== global_dc
);
356 gcc_assert (kind
== DK_UNSPECIFIED
);
357 return targetm_common
.handle_option (opts
, opts_set
, decoded
, loc
);
360 /* Add comma-separated strings to a char_p vector. */
363 add_comma_separated_to_vector (void **pvec
, const char *arg
)
369 vec
<char_p
> *v
= (vec
<char_p
> *) *pvec
;
371 vec_check_alloc (v
, 1);
373 /* We never free this string. */
386 v
->safe_push (token_start
);
389 if (*r
== '\\' && r
[1] == ',')
399 if (*token_start
!= '\0')
400 v
->safe_push (token_start
);
405 /* Initialize opts_obstack. */
408 init_opts_obstack (void)
410 gcc_obstack_init (&opts_obstack
);
413 /* Initialize OPTS and OPTS_SET before using them in parsing options. */
416 init_options_struct (struct gcc_options
*opts
, struct gcc_options
*opts_set
)
418 /* Ensure that opts_obstack has already been initialized by the time
419 that we initialize any gcc_options instances (PR jit/68446). */
420 gcc_assert (opts_obstack
.chunk_size
> 0);
422 *opts
= global_options_init
;
425 memset (opts_set
, 0, sizeof (*opts_set
));
427 /* Initialize whether `char' is signed. */
428 opts
->x_flag_signed_char
= DEFAULT_SIGNED_CHAR
;
429 /* Set this to a special "uninitialized" value. The actual default
430 is set after target options have been processed. */
431 opts
->x_flag_short_enums
= 2;
433 /* Initialize target_flags before default_options_optimization
434 so the latter can modify it. */
435 opts
->x_target_flags
= targetm_common
.default_target_flags
;
437 /* Some targets have ABI-specified unwind tables. */
438 opts
->x_flag_unwind_tables
= targetm_common
.unwind_tables_default
;
440 /* Some targets have other target-specific initialization. */
441 targetm_common
.option_init_struct (opts
);
444 /* If indicated by the optimization level LEVEL (-Os if SIZE is set,
445 -Ofast if FAST is set, -Og if DEBUG is set), apply the option DEFAULT_OPT
446 to OPTS and OPTS_SET, diagnostic context DC, location LOC, with language
447 mask LANG_MASK and option handlers HANDLERS. */
450 maybe_default_option (struct gcc_options
*opts
,
451 struct gcc_options
*opts_set
,
452 const struct default_options
*default_opt
,
453 int level
, bool size
, bool fast
, bool debug
,
454 unsigned int lang_mask
,
455 const struct cl_option_handlers
*handlers
,
457 diagnostic_context
*dc
)
459 const struct cl_option
*option
= &cl_options
[default_opt
->opt_index
];
463 gcc_assert (level
== 2);
465 gcc_assert (level
== 3);
467 gcc_assert (level
== 1);
469 switch (default_opt
->levels
)
475 case OPT_LEVELS_0_ONLY
:
476 enabled
= (level
== 0);
479 case OPT_LEVELS_1_PLUS
:
480 enabled
= (level
>= 1);
483 case OPT_LEVELS_1_PLUS_SPEED_ONLY
:
484 enabled
= (level
>= 1 && !size
&& !debug
);
487 case OPT_LEVELS_1_PLUS_NOT_DEBUG
:
488 enabled
= (level
>= 1 && !debug
);
491 case OPT_LEVELS_2_PLUS
:
492 enabled
= (level
>= 2);
495 case OPT_LEVELS_2_PLUS_SPEED_ONLY
:
496 enabled
= (level
>= 2 && !size
&& !debug
);
499 case OPT_LEVELS_3_PLUS
:
500 enabled
= (level
>= 3);
503 case OPT_LEVELS_3_PLUS_AND_SIZE
:
504 enabled
= (level
>= 3 || size
);
507 case OPT_LEVELS_SIZE
:
511 case OPT_LEVELS_FAST
:
515 case OPT_LEVELS_NONE
:
521 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
522 default_opt
->arg
, default_opt
->value
,
523 lang_mask
, DK_UNSPECIFIED
, loc
,
525 else if (default_opt
->arg
== NULL
526 && !option
->cl_reject_negative
527 && !(option
->flags
& CL_PARAMS
))
528 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
529 default_opt
->arg
, !default_opt
->value
,
530 lang_mask
, DK_UNSPECIFIED
, loc
,
534 /* As indicated by the optimization level LEVEL (-Os if SIZE is set,
535 -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
536 OPTS and OPTS_SET, diagnostic context DC, location LOC, with
537 language mask LANG_MASK and option handlers HANDLERS. */
540 maybe_default_options (struct gcc_options
*opts
,
541 struct gcc_options
*opts_set
,
542 const struct default_options
*default_opts
,
543 int level
, bool size
, bool fast
, bool debug
,
544 unsigned int lang_mask
,
545 const struct cl_option_handlers
*handlers
,
547 diagnostic_context
*dc
)
551 for (i
= 0; default_opts
[i
].levels
!= OPT_LEVELS_NONE
; i
++)
552 maybe_default_option (opts
, opts_set
, &default_opts
[i
],
553 level
, size
, fast
, debug
,
554 lang_mask
, handlers
, loc
, dc
);
557 /* Table of options enabled by default at different levels.
558 Please keep this list sorted by level and alphabetized within
559 each level; this makes it easier to keep the documentation
562 static const struct default_options default_options_table
[] =
564 /* -O1 and -Og optimizations. */
565 { OPT_LEVELS_1_PLUS
, OPT_fcombine_stack_adjustments
, NULL
, 1 },
566 { OPT_LEVELS_1_PLUS
, OPT_fcompare_elim
, NULL
, 1 },
567 { OPT_LEVELS_1_PLUS
, OPT_fcprop_registers
, NULL
, 1 },
568 { OPT_LEVELS_1_PLUS
, OPT_fdefer_pop
, NULL
, 1 },
569 { OPT_LEVELS_1_PLUS
, OPT_fforward_propagate
, NULL
, 1 },
570 { OPT_LEVELS_1_PLUS
, OPT_fguess_branch_probability
, NULL
, 1 },
571 { OPT_LEVELS_1_PLUS
, OPT_fipa_profile
, NULL
, 1 },
572 { OPT_LEVELS_1_PLUS
, OPT_fipa_pure_const
, NULL
, 1 },
573 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference
, NULL
, 1 },
574 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference_addressable
, NULL
, 1 },
575 { OPT_LEVELS_1_PLUS
, OPT_fmerge_constants
, NULL
, 1 },
576 { OPT_LEVELS_1_PLUS
, OPT_fomit_frame_pointer
, NULL
, 1 },
577 { OPT_LEVELS_1_PLUS
, OPT_freorder_blocks
, NULL
, 1 },
578 { OPT_LEVELS_1_PLUS
, OPT_fshrink_wrap
, NULL
, 1 },
579 { OPT_LEVELS_1_PLUS
, OPT_fsplit_wide_types
, NULL
, 1 },
580 { OPT_LEVELS_1_PLUS
, OPT_fthread_jumps
, NULL
, 1 },
581 { OPT_LEVELS_1_PLUS
, OPT_ftree_builtin_call_dce
, NULL
, 1 },
582 { OPT_LEVELS_1_PLUS
, OPT_ftree_ccp
, NULL
, 1 },
583 { OPT_LEVELS_1_PLUS
, OPT_ftree_ch
, NULL
, 1 },
584 { OPT_LEVELS_1_PLUS
, OPT_ftree_coalesce_vars
, NULL
, 1 },
585 { OPT_LEVELS_1_PLUS
, OPT_ftree_copy_prop
, NULL
, 1 },
586 { OPT_LEVELS_1_PLUS
, OPT_ftree_dce
, NULL
, 1 },
587 { OPT_LEVELS_1_PLUS
, OPT_ftree_dominator_opts
, NULL
, 1 },
588 { OPT_LEVELS_1_PLUS
, OPT_ftree_fre
, NULL
, 1 },
589 { OPT_LEVELS_1_PLUS
, OPT_ftree_sink
, NULL
, 1 },
590 { OPT_LEVELS_1_PLUS
, OPT_ftree_slsr
, NULL
, 1 },
591 { OPT_LEVELS_1_PLUS
, OPT_ftree_ter
, NULL
, 1 },
592 { OPT_LEVELS_1_PLUS
, OPT_fvar_tracking
, NULL
, 1 },
594 /* -O1 (and not -Og) optimizations. */
595 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fbranch_count_reg
, NULL
, 1 },
597 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fdelayed_branch
, NULL
, 1 },
599 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fdse
, NULL
, 1 },
600 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion
, NULL
, 1 },
601 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion2
, NULL
, 1 },
602 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_finline_functions_called_once
, NULL
, 1 },
603 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_invariants
, NULL
, 1 },
604 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_stores
, NULL
, 1 },
605 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fssa_phiopt
, NULL
, 1 },
606 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fipa_modref
, NULL
, 1 },
607 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_bit_ccp
, NULL
, 1 },
608 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_dse
, NULL
, 1 },
609 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_pta
, NULL
, 1 },
610 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_sra
, NULL
, 1 },
612 /* -O2 and -Os optimizations. */
613 { OPT_LEVELS_2_PLUS
, OPT_fcaller_saves
, NULL
, 1 },
614 { OPT_LEVELS_2_PLUS
, OPT_fcode_hoisting
, NULL
, 1 },
615 { OPT_LEVELS_2_PLUS
, OPT_fcrossjumping
, NULL
, 1 },
616 { OPT_LEVELS_2_PLUS
, OPT_fcse_follow_jumps
, NULL
, 1 },
617 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize
, NULL
, 1 },
618 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize_speculatively
, NULL
, 1 },
619 { OPT_LEVELS_2_PLUS
, OPT_fexpensive_optimizations
, NULL
, 1 },
620 { OPT_LEVELS_2_PLUS
, OPT_fgcse
, NULL
, 1 },
621 { OPT_LEVELS_2_PLUS
, OPT_fhoist_adjacent_loads
, NULL
, 1 },
622 { OPT_LEVELS_2_PLUS
, OPT_findirect_inlining
, NULL
, 1 },
623 { OPT_LEVELS_2_PLUS
, OPT_finline_small_functions
, NULL
, 1 },
624 { OPT_LEVELS_2_PLUS
, OPT_fipa_bit_cp
, NULL
, 1 },
625 { OPT_LEVELS_2_PLUS
, OPT_fipa_cp
, NULL
, 1 },
626 { OPT_LEVELS_2_PLUS
, OPT_fipa_icf
, NULL
, 1 },
627 { OPT_LEVELS_2_PLUS
, OPT_fipa_ra
, NULL
, 1 },
628 { OPT_LEVELS_2_PLUS
, OPT_fipa_sra
, NULL
, 1 },
629 { OPT_LEVELS_2_PLUS
, OPT_fipa_vrp
, NULL
, 1 },
630 { OPT_LEVELS_2_PLUS
, OPT_fisolate_erroneous_paths_dereference
, NULL
, 1 },
631 { OPT_LEVELS_2_PLUS
, OPT_flra_remat
, NULL
, 1 },
632 { OPT_LEVELS_2_PLUS
, OPT_foptimize_sibling_calls
, NULL
, 1 },
633 { OPT_LEVELS_2_PLUS
, OPT_fpartial_inlining
, NULL
, 1 },
634 { OPT_LEVELS_2_PLUS
, OPT_fpeephole2
, NULL
, 1 },
635 { OPT_LEVELS_2_PLUS
, OPT_freorder_functions
, NULL
, 1 },
636 { OPT_LEVELS_2_PLUS
, OPT_frerun_cse_after_loop
, NULL
, 1 },
637 #ifdef INSN_SCHEDULING
638 { OPT_LEVELS_2_PLUS
, OPT_fschedule_insns2
, NULL
, 1 },
640 { OPT_LEVELS_2_PLUS
, OPT_fstrict_aliasing
, NULL
, 1 },
641 { OPT_LEVELS_2_PLUS
, OPT_fstore_merging
, NULL
, 1 },
642 { OPT_LEVELS_2_PLUS
, OPT_ftree_pre
, NULL
, 1 },
643 { OPT_LEVELS_2_PLUS
, OPT_ftree_switch_conversion
, NULL
, 1 },
644 { OPT_LEVELS_2_PLUS
, OPT_ftree_tail_merge
, NULL
, 1 },
645 { OPT_LEVELS_2_PLUS
, OPT_ftree_vrp
, NULL
, 1 },
646 { OPT_LEVELS_2_PLUS
, OPT_fvect_cost_model_
, NULL
,
647 VECT_COST_MODEL_VERY_CHEAP
},
648 { OPT_LEVELS_2_PLUS
, OPT_finline_functions
, NULL
, 1 },
649 { OPT_LEVELS_2_PLUS
, OPT_ftree_loop_distribute_patterns
, NULL
, 1 },
651 /* -O2 and above optimizations, but not -Os or -Og. */
652 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_functions
, NULL
, 1 },
653 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_jumps
, NULL
, 1 },
654 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_labels
, NULL
, 1 },
655 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_loops
, NULL
, 1 },
656 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_foptimize_strlen
, NULL
, 1 },
657 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_freorder_blocks_algorithm_
, NULL
,
658 REORDER_BLOCKS_ALGORITHM_STC
},
659 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_ftree_loop_vectorize
, NULL
, 1 },
660 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_ftree_slp_vectorize
, NULL
, 1 },
661 #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 /* At -O0 or -Og, turn __builtin_unreachable into a trap. */
1126 if (!opts
->x_optimize
|| opts
->x_optimize_debug
)
1127 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unreachable_traps
, true);
1129 /* Pipelining of outer loops is only possible when general pipelining
1130 capabilities are requested. */
1131 if (!opts
->x_flag_sel_sched_pipelining
)
1132 opts
->x_flag_sel_sched_pipelining_outer_loops
= 0;
1134 if (opts
->x_flag_conserve_stack
)
1136 SET_OPTION_IF_UNSET (opts
, opts_set
, param_large_stack_frame
, 100);
1137 SET_OPTION_IF_UNSET (opts
, opts_set
, param_stack_frame_growth
, 40);
1140 if (opts
->x_flag_lto
)
1143 opts
->x_flag_generate_lto
= 1;
1145 /* When generating IL, do not operate in whole-program mode.
1146 Otherwise, symbols will be privatized too early, causing link
1148 opts
->x_flag_whole_program
= 0;
1150 error_at (loc
, "LTO support has not been enabled in this configuration");
1152 if (!opts
->x_flag_fat_lto_objects
1153 && (!HAVE_LTO_PLUGIN
1154 || (opts_set
->x_flag_use_linker_plugin
1155 && !opts
->x_flag_use_linker_plugin
)))
1157 if (opts_set
->x_flag_fat_lto_objects
)
1158 error_at (loc
, "%<-fno-fat-lto-objects%> are supported only with "
1160 opts
->x_flag_fat_lto_objects
= 1;
1163 /* -gsplit-dwarf isn't compatible with LTO, see PR88389. */
1164 if (opts
->x_dwarf_split_debug_info
)
1166 inform (loc
, "%<-gsplit-dwarf%> is not supported with LTO,"
1168 opts
->x_dwarf_split_debug_info
= 0;
1172 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
1173 default value if they choose based on other options. */
1174 if (opts
->x_flag_split_stack
== -1)
1175 opts
->x_flag_split_stack
= 0;
1176 else if (opts
->x_flag_split_stack
)
1178 if (!targetm_common
.supports_split_stack (true, opts
))
1180 error_at (loc
, "%<-fsplit-stack%> is not supported by "
1181 "this compiler configuration");
1182 opts
->x_flag_split_stack
= 0;
1186 /* If stack splitting is turned on, and the user did not explicitly
1187 request function partitioning, turn off partitioning, as it
1188 confuses the linker when trying to handle partitioned split-stack
1189 code that calls a non-split-stack functions. But if partitioning
1190 was turned on explicitly just hope for the best. */
1191 if (opts
->x_flag_split_stack
1192 && opts
->x_flag_reorder_blocks_and_partition
)
1193 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_reorder_blocks_and_partition
, 0);
1195 if (opts
->x_flag_reorder_blocks_and_partition
)
1196 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_reorder_functions
, 1);
1198 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
1199 if (opts
->x_dwarf_split_debug_info
)
1200 opts
->x_debug_generate_pub_sections
= 2;
1202 if ((opts
->x_flag_sanitize
1203 & (SANITIZE_USER_ADDRESS
| SANITIZE_KERNEL_ADDRESS
)) == 0)
1205 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_COMPARE
)
1207 "%<-fsanitize=pointer-compare%> must be combined with "
1208 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1209 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_SUBTRACT
)
1211 "%<-fsanitize=pointer-subtract%> must be combined with "
1212 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1215 /* Address sanitizers conflict with the thread sanitizer. */
1216 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_THREAD
,
1218 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_THREAD
,
1219 SANITIZE_HWADDRESS
);
1220 /* The leak sanitizer conflicts with the thread sanitizer. */
1221 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_LEAK
,
1224 /* No combination of HWASAN and ASAN work together. */
1225 report_conflicting_sanitizer_options (opts
, loc
,
1226 SANITIZE_HWADDRESS
, SANITIZE_ADDRESS
);
1228 /* The userspace and kernel address sanitizers conflict with each other. */
1229 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_USER_HWADDRESS
,
1230 SANITIZE_KERNEL_HWADDRESS
);
1231 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_USER_ADDRESS
,
1232 SANITIZE_KERNEL_ADDRESS
);
1234 /* Check error recovery for -fsanitize-recover option. */
1235 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1236 if ((opts
->x_flag_sanitize_recover
& sanitizer_opts
[i
].flag
)
1237 && !sanitizer_opts
[i
].can_recover
)
1238 error_at (loc
, "%<-fsanitize-recover=%s%> is not supported",
1239 sanitizer_opts
[i
].name
);
1241 /* Check -fsanitize-trap option. */
1242 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1243 if ((opts
->x_flag_sanitize_trap
& sanitizer_opts
[i
].flag
)
1244 && !sanitizer_opts
[i
].can_trap
1245 /* Allow -fsanitize-trap=all or -fsanitize-trap=undefined
1246 to set flag_sanitize_trap & SANITIZE_VPTR bit which will
1247 effectively disable -fsanitize=vptr, just disallow
1248 explicit -fsanitize-trap=vptr. */
1249 && sanitizer_opts
[i
].flag
!= SANITIZE_VPTR
)
1250 error_at (loc
, "%<-fsanitize-trap=%s%> is not supported",
1251 sanitizer_opts
[i
].name
);
1253 /* When instrumenting the pointers, we don't want to remove
1254 the null pointer checks. */
1255 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
1256 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
1257 opts
->x_flag_delete_null_pointer_checks
= 0;
1259 /* Aggressive compiler optimizations may cause false negatives. */
1260 if (opts
->x_flag_sanitize
& ~(SANITIZE_LEAK
| SANITIZE_UNREACHABLE
))
1261 opts
->x_flag_aggressive_loop_optimizations
= 0;
1263 /* Enable -fsanitize-address-use-after-scope if either address sanitizer is
1265 if (opts
->x_flag_sanitize
1266 & (SANITIZE_USER_ADDRESS
| SANITIZE_USER_HWADDRESS
))
1267 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_sanitize_address_use_after_scope
,
1270 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1272 if (opts
->x_flag_sanitize_address_use_after_scope
)
1274 if (opts
->x_flag_stack_reuse
!= SR_NONE
1275 && opts_set
->x_flag_stack_reuse
!= SR_NONE
)
1277 "%<-fsanitize-address-use-after-scope%> requires "
1278 "%<-fstack-reuse=none%> option");
1280 opts
->x_flag_stack_reuse
= SR_NONE
;
1283 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
) && opts
->x_flag_tm
)
1284 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1286 if ((opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) && opts
->x_flag_tm
)
1287 sorry ("transactional memory is not supported with "
1288 "%<-fsanitize=kernel-address%>");
1290 /* Currently live patching is not support for LTO. */
1291 if (opts
->x_flag_live_patching
&& opts
->x_flag_lto
)
1292 sorry ("live patching is not supported with LTO");
1294 /* Currently vtable verification is not supported for LTO */
1295 if (opts
->x_flag_vtable_verify
&& opts
->x_flag_lto
)
1296 sorry ("vtable verification is not supported with LTO");
1298 /* Control IPA optimizations based on different -flive-patching level. */
1299 if (opts
->x_flag_live_patching
)
1300 control_options_for_live_patching (opts
, opts_set
,
1301 opts
->x_flag_live_patching
,
1304 /* Allow cunroll to grow size accordingly. */
1305 if (!opts_set
->x_flag_cunroll_grow_size
)
1306 opts
->x_flag_cunroll_grow_size
1307 = (opts
->x_flag_unroll_loops
1308 || opts
->x_flag_peel_loops
1309 || opts
->x_optimize
>= 3);
1311 /* With -fcx-limited-range, we do cheap and quick complex arithmetic. */
1312 if (opts
->x_flag_cx_limited_range
)
1313 opts
->x_flag_complex_method
= 0;
1314 else if (opts_set
->x_flag_cx_limited_range
)
1315 opts
->x_flag_complex_method
= opts
->x_flag_default_complex_method
;
1317 /* With -fcx-fortran-rules, we do something in-between cheap and C99. */
1318 if (opts
->x_flag_cx_fortran_rules
)
1319 opts
->x_flag_complex_method
= 1;
1320 else if (opts_set
->x_flag_cx_fortran_rules
)
1321 opts
->x_flag_complex_method
= opts
->x_flag_default_complex_method
;
1323 /* Use -fvect-cost-model=cheap instead of -fvect-cost-mode=very-cheap
1324 by default with explicit -ftree-{loop,slp}-vectorize. */
1325 if (opts
->x_optimize
== 2
1326 && (opts_set
->x_flag_tree_loop_vectorize
1327 || opts_set
->x_flag_tree_vectorize
))
1328 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_vect_cost_model
,
1329 VECT_COST_MODEL_CHEAP
);
1331 if (opts
->x_flag_gtoggle
)
1333 /* Make sure to process -gtoggle only once. */
1334 opts
->x_flag_gtoggle
= false;
1335 if (opts
->x_debug_info_level
== DINFO_LEVEL_NONE
)
1337 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
1339 if (opts
->x_write_symbols
== NO_DEBUG
)
1340 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
1343 opts
->x_debug_info_level
= DINFO_LEVEL_NONE
;
1346 if (!opts_set
->x_debug_nonbind_markers_p
)
1347 opts
->x_debug_nonbind_markers_p
1349 && opts
->x_debug_info_level
>= DINFO_LEVEL_NORMAL
1350 && dwarf_debuginfo_p (opts
)
1351 && !(opts
->x_flag_selective_scheduling
1352 || opts
->x_flag_selective_scheduling2
));
1354 /* We know which debug output will be used so we can set flag_var_tracking
1355 and flag_var_tracking_uninit if the user has not specified them. */
1356 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
1357 || !dwarf_debuginfo_p (opts
)
1358 /* We have not yet initialized debug hooks so match that to check
1359 whether we're only doing DWARF2_LINENO_DEBUGGING_INFO. */
1360 #ifndef DWARF2_DEBUGGING_INFO
1365 if ((opts_set
->x_flag_var_tracking
&& opts
->x_flag_var_tracking
== 1)
1366 || (opts_set
->x_flag_var_tracking_uninit
1367 && opts
->x_flag_var_tracking_uninit
== 1))
1369 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
1370 warning_at (UNKNOWN_LOCATION
, 0,
1371 "variable tracking requested, but useless unless "
1372 "producing debug info");
1374 warning_at (UNKNOWN_LOCATION
, 0,
1375 "variable tracking requested, but not supported "
1376 "by this debug format");
1378 opts
->x_flag_var_tracking
= 0;
1379 opts
->x_flag_var_tracking_uninit
= 0;
1382 /* One could use EnabledBy, but it would lead to a circular dependency. */
1383 if (!opts_set
->x_flag_var_tracking_uninit
)
1384 opts
->x_flag_var_tracking_uninit
= opts
->x_flag_var_tracking
;
1386 if (!opts_set
->x_flag_var_tracking_assignments
)
1387 opts
->x_flag_var_tracking_assignments
1388 = (opts
->x_flag_var_tracking
1389 && !(opts
->x_flag_selective_scheduling
1390 || opts
->x_flag_selective_scheduling2
));
1392 if (opts
->x_flag_var_tracking_assignments_toggle
)
1393 opts
->x_flag_var_tracking_assignments
1394 = !opts
->x_flag_var_tracking_assignments
;
1396 if (opts
->x_flag_var_tracking_assignments
&& !opts
->x_flag_var_tracking
)
1397 opts
->x_flag_var_tracking
= opts
->x_flag_var_tracking_assignments
= -1;
1399 if (opts
->x_flag_var_tracking_assignments
1400 && (opts
->x_flag_selective_scheduling
1401 || opts
->x_flag_selective_scheduling2
))
1403 "var-tracking-assignments changes selective scheduling");
1405 if (opts
->x_flag_syntax_only
)
1407 opts
->x_write_symbols
= NO_DEBUG
;
1408 opts
->x_profile_flag
= 0;
1412 diagnose_options (opts
, opts_set
, loc
);
1415 /* The function diagnoses incompatible combinations for provided options
1416 (OPTS and OPTS_SET) at a given LOCation. The function is called both
1417 when command line is parsed (after the target optimization hook) and
1418 when an optimize/target attribute (or pragma) is used. */
1420 void diagnose_options (gcc_options
*opts
, gcc_options
*opts_set
,
1423 /* The optimization to partition hot and cold basic blocks into separate
1424 sections of the .o and executable files does not work (currently)
1425 with exception handling. This is because there is no support for
1426 generating unwind info. If opts->x_flag_exceptions is turned on
1427 we need to turn off the partitioning optimization. */
1429 enum unwind_info_type ui_except
1430 = targetm_common
.except_unwind_info (opts
);
1432 if (opts
->x_flag_exceptions
1433 && opts
->x_flag_reorder_blocks_and_partition
1434 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1436 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1438 "%<-freorder-blocks-and-partition%> does not work "
1439 "with exceptions on this architecture");
1440 opts
->x_flag_reorder_blocks_and_partition
= 0;
1441 opts
->x_flag_reorder_blocks
= 1;
1444 /* If user requested unwind info, then turn off the partitioning
1447 if (opts
->x_flag_unwind_tables
1448 && !targetm_common
.unwind_tables_default
1449 && opts
->x_flag_reorder_blocks_and_partition
1450 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1452 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1454 "%<-freorder-blocks-and-partition%> does not support "
1455 "unwind info on this architecture");
1456 opts
->x_flag_reorder_blocks_and_partition
= 0;
1457 opts
->x_flag_reorder_blocks
= 1;
1460 /* If the target requested unwind info, then turn off the partitioning
1461 optimization with a different message. Likewise, if the target does not
1462 support named sections. */
1464 if (opts
->x_flag_reorder_blocks_and_partition
1465 && (!targetm_common
.have_named_sections
1466 || (opts
->x_flag_unwind_tables
1467 && targetm_common
.unwind_tables_default
1468 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
1470 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1472 "%<-freorder-blocks-and-partition%> does not work "
1473 "on this architecture");
1474 opts
->x_flag_reorder_blocks_and_partition
= 0;
1475 opts
->x_flag_reorder_blocks
= 1;
1481 #define LEFT_COLUMN 27
1483 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1484 followed by word-wrapped HELP in a second column. */
1486 wrap_help (const char *help
,
1488 unsigned int item_width
,
1489 unsigned int columns
)
1491 unsigned int col_width
= LEFT_COLUMN
;
1492 unsigned int remaining
, room
, len
;
1494 remaining
= strlen (help
);
1498 room
= columns
- 3 - MAX (col_width
, item_width
);
1507 for (i
= 0; help
[i
]; i
++)
1509 if (i
>= room
&& len
!= remaining
)
1513 else if ((help
[i
] == '-' || help
[i
] == '/')
1514 && help
[i
+ 1] != ' '
1515 && i
> 0 && ISALPHA (help
[i
- 1]))
1520 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1522 while (help
[len
] == ' ')
1530 /* Data structure used to print list of valid option values. */
1532 class option_help_tuple
1535 option_help_tuple (int code
, vec
<const char *> values
):
1536 m_code (code
), m_values (values
)
1539 /* Code of an option. */
1542 /* List of possible values. */
1543 vec
<const char *> m_values
;
1546 /* Print help for a specific front-end, etc. */
1548 print_filtered_help (unsigned int include_flags
,
1549 unsigned int exclude_flags
,
1550 unsigned int any_flags
,
1551 unsigned int columns
,
1552 struct gcc_options
*opts
,
1553 unsigned int lang_mask
)
1558 bool displayed
= false;
1561 if (!opts
->x_help_printed
)
1562 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1564 if (!opts
->x_help_enum_printed
)
1565 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1567 auto_vec
<option_help_tuple
> help_tuples
;
1569 for (i
= 0; i
< cl_options_count
; i
++)
1571 const struct cl_option
*option
= cl_options
+ i
;
1576 if (include_flags
== 0
1577 || ((option
->flags
& include_flags
) != include_flags
))
1579 if ((option
->flags
& any_flags
) == 0)
1583 /* Skip unwanted switches. */
1584 if ((option
->flags
& exclude_flags
) != 0)
1587 /* The driver currently prints its own help text. */
1588 if ((option
->flags
& CL_DRIVER
) != 0
1589 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1590 | CL_COMMON
| CL_TARGET
)) == 0)
1593 /* If an option contains a language specification,
1594 exclude it from common unless all languages are present. */
1595 if ((include_flags
& CL_COMMON
)
1596 && !(option
->flags
& CL_DRIVER
)
1597 && (option
->flags
& CL_LANG_ALL
)
1598 && (option
->flags
& CL_LANG_ALL
) != CL_LANG_ALL
)
1602 /* Skip switches that have already been printed. */
1603 if (opts
->x_help_printed
[i
])
1606 opts
->x_help_printed
[i
] = true;
1608 help
= option
->help
;
1611 if (exclude_flags
& CL_UNDOCUMENTED
)
1614 help
= undocumented_msg
;
1617 /* Get the translation. */
1620 if (option
->alias_target
< N_OPTS
1621 && cl_options
[option
->alias_target
].help
)
1623 const struct cl_option
*target
= cl_options
+ option
->alias_target
;
1624 if (option
->help
== NULL
)
1626 /* The option is undocumented but is an alias for an option that
1627 is documented. If the option has alias arguments, then its
1628 purpose is to provide certain arguments to the other option, so
1629 inform the reader of this. Otherwise, point the reader to the
1630 other option in preference to the former. */
1632 if (option
->alias_arg
)
1634 if (option
->neg_alias_arg
)
1635 snprintf (new_help
, sizeof new_help
,
1636 _("Same as %s%s (or, in negated form, %s%s)."),
1637 target
->opt_text
, option
->alias_arg
,
1638 target
->opt_text
, option
->neg_alias_arg
);
1640 snprintf (new_help
, sizeof new_help
,
1642 target
->opt_text
, option
->alias_arg
);
1645 snprintf (new_help
, sizeof new_help
,
1651 /* For documented options with aliases, mention the aliased
1652 option's name for reference. */
1653 snprintf (new_help
, sizeof new_help
,
1654 _("%s Same as %s."),
1655 help
, cl_options
[option
->alias_target
].opt_text
);
1661 if (option
->warn_message
)
1663 /* Mention that the use of the option will trigger a warning. */
1664 if (help
== new_help
)
1665 snprintf (new_help
+ strlen (new_help
),
1666 sizeof new_help
- strlen (new_help
),
1667 " %s", _(use_diagnosed_msg
));
1669 snprintf (new_help
, sizeof new_help
,
1670 "%s %s", help
, _(use_diagnosed_msg
));
1675 /* Find the gap between the name of the
1676 option and its descriptive text. */
1677 tab
= strchr (help
, '\t');
1686 opt
= option
->opt_text
;
1690 /* With the -Q option enabled we change the descriptive text associated
1691 with an option to be an indication of its current setting. */
1692 if (!opts
->x_quiet_flag
)
1694 void *flag_var
= option_flag_var (i
, opts
);
1696 if (len
< (LEFT_COLUMN
+ 2))
1697 strcpy (new_help
, "\t\t");
1699 strcpy (new_help
, "\t");
1701 /* Set to print whether the option is enabled or disabled,
1702 or, if it's an alias for another option, the name of
1703 the aliased option. */
1704 bool print_state
= false;
1706 if (flag_var
!= NULL
1707 && option
->var_type
!= CLVC_DEFER
)
1709 /* If OPTION is only available for a specific subset
1710 of languages other than this one, mention them. */
1711 bool avail_for_lang
= true;
1712 if (unsigned langset
= option
->flags
& CL_LANG_ALL
)
1714 if (!(langset
& lang_mask
))
1716 avail_for_lang
= false;
1717 strcat (new_help
, _("[available in "));
1718 for (unsigned i
= 0, n
= 0; (1U << i
) < CL_LANG_ALL
; ++i
)
1719 if (langset
& (1U << i
))
1722 strcat (new_help
, ", ");
1723 strcat (new_help
, lang_names
[i
]);
1725 strcat (new_help
, "]");
1728 if (!avail_for_lang
)
1729 ; /* Print nothing else if the option is not available
1730 in the current language. */
1731 else if (option
->flags
& CL_JOINED
)
1733 if (option
->var_type
== CLVC_STRING
)
1735 if (* (const char **) flag_var
!= NULL
)
1736 snprintf (new_help
+ strlen (new_help
),
1737 sizeof (new_help
) - strlen (new_help
),
1738 "%s", * (const char **) flag_var
);
1740 else if (option
->var_type
== CLVC_ENUM
)
1742 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1744 const char *arg
= NULL
;
1746 value
= e
->get (flag_var
);
1747 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1749 arg
= _("[default]");
1750 snprintf (new_help
+ strlen (new_help
),
1751 sizeof (new_help
) - strlen (new_help
),
1756 if (option
->cl_host_wide_int
)
1757 sprintf (new_help
+ strlen (new_help
),
1758 _("%llu bytes"), (unsigned long long)
1759 *(unsigned HOST_WIDE_INT
*) flag_var
);
1761 sprintf (new_help
+ strlen (new_help
),
1762 "%i", * (int *) flag_var
);
1769 /* When there is no argument, print the option state only
1770 if the option takes no argument. */
1771 print_state
= !(option
->flags
& CL_JOINED
);
1775 if (option
->alias_target
< N_OPTS
1776 && option
->alias_target
!= OPT_SPECIAL_warn_removed
1777 && option
->alias_target
!= OPT_SPECIAL_ignore
1778 && option
->alias_target
!= OPT_SPECIAL_input_file
1779 && option
->alias_target
!= OPT_SPECIAL_program_name
1780 && option
->alias_target
!= OPT_SPECIAL_unknown
)
1782 const struct cl_option
*target
1783 = &cl_options
[option
->alias_target
];
1784 sprintf (new_help
+ strlen (new_help
), "%s%s",
1786 option
->alias_arg
? option
->alias_arg
: "");
1788 else if (option
->alias_target
== OPT_SPECIAL_ignore
)
1789 strcat (new_help
, ("[ignored]"));
1792 /* Print the state for an on/off option. */
1793 int ena
= option_enabled (i
, lang_mask
, opts
);
1795 strcat (new_help
, _("[enabled]"));
1797 strcat (new_help
, _("[disabled]"));
1804 if (option
->range_max
!= -1)
1807 snprintf (b
, sizeof (b
), "<%d,%d>", option
->range_min
,
1809 opt
= concat (opt
, b
, NULL
);
1813 wrap_help (help
, opt
, len
, columns
);
1816 if (option
->var_type
== CLVC_ENUM
1817 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1818 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1821 vec
<const char *> option_values
1822 = targetm_common
.get_valid_option_values (i
, NULL
);
1823 if (!option_values
.is_empty ())
1824 help_tuples
.safe_push (option_help_tuple (i
, option_values
));
1830 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1833 printf (_(" No options with the desired characteristics were found\n"));
1838 /* PR 31349: Tell the user how to see all of the
1839 options supported by a specific front end. */
1840 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1841 if ((1U << i
) & langs
)
1842 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1843 lang_names
[i
], lang_names
[i
]);
1847 else if (! displayed
)
1848 printf (_(" All options with the desired characteristics have already been displayed\n"));
1852 /* Print details of enumerated option arguments, if those
1853 enumerations have help text headings provided. If no help text
1854 is provided, presume that the possible values are listed in the
1855 help text for the relevant options. */
1856 for (i
= 0; i
< cl_enums_count
; i
++)
1858 unsigned int j
, pos
;
1860 if (opts
->x_help_enum_printed
[i
] != 1)
1862 if (cl_enums
[i
].help
== NULL
)
1864 printf (" %s\n ", _(cl_enums
[i
].help
));
1866 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1868 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1870 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1872 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1882 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1887 opts
->x_help_enum_printed
[i
] = 2;
1890 for (unsigned i
= 0; i
< help_tuples
.length (); i
++)
1892 const struct cl_option
*option
= cl_options
+ help_tuples
[i
].m_code
;
1893 printf (_(" Known valid arguments for %s option:\n "),
1895 for (unsigned j
= 0; j
< help_tuples
[i
].m_values
.length (); j
++)
1896 printf (" %s", help_tuples
[i
].m_values
[j
]);
1901 /* Display help for a specified type of option.
1902 The options must have ALL of the INCLUDE_FLAGS set
1903 ANY of the flags in the ANY_FLAGS set
1904 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1905 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1907 print_specific_help (unsigned int include_flags
,
1908 unsigned int exclude_flags
,
1909 unsigned int any_flags
,
1910 struct gcc_options
*opts
,
1911 unsigned int lang_mask
)
1913 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1914 const char * description
= NULL
;
1915 const char * descrip_extra
= "";
1919 /* Sanity check: Make sure that we do not have more
1920 languages than we have bits available to enumerate them. */
1921 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1923 /* If we have not done so already, obtain
1924 the desired maximum width of the output. */
1925 if (opts
->x_help_columns
== 0)
1927 opts
->x_help_columns
= get_terminal_width ();
1928 if (opts
->x_help_columns
== INT_MAX
)
1929 /* Use a reasonable default. */
1930 opts
->x_help_columns
= 80;
1933 /* Decide upon the title for the options that we are going to display. */
1934 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1936 switch (flag
& include_flags
)
1943 description
= _("The following options are target specific");
1946 description
= _("The following options control compiler warning messages");
1948 case CL_OPTIMIZATION
:
1949 description
= _("The following options control optimizations");
1952 description
= _("The following options are language-independent");
1955 description
= _("The following options control parameters");
1958 if (i
>= cl_lang_count
)
1960 if (exclude_flags
& all_langs_mask
)
1961 description
= _("The following options are specific to just the language ");
1963 description
= _("The following options are supported by the language ");
1964 descrip_extra
= lang_names
[i
];
1969 if (description
== NULL
)
1973 if (include_flags
& CL_UNDOCUMENTED
)
1974 description
= _("The following options are not documented");
1975 else if (include_flags
& CL_SEPARATE
)
1976 description
= _("The following options take separate arguments");
1977 else if (include_flags
& CL_JOINED
)
1978 description
= _("The following options take joined arguments");
1981 internal_error ("unrecognized %<include_flags 0x%x%> passed "
1982 "to %<print_specific_help%>",
1989 if (any_flags
& all_langs_mask
)
1990 description
= _("The following options are language-related");
1992 description
= _("The following options are language-independent");
1996 printf ("%s%s:\n", description
, descrip_extra
);
1997 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
1998 opts
->x_help_columns
, opts
, lang_mask
);
2001 /* Enable FDO-related flags. */
2004 enable_fdo_optimizations (struct gcc_options
*opts
,
2005 struct gcc_options
*opts_set
,
2008 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_branch_probabilities
, value
);
2009 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
2010 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_loops
, value
);
2011 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_peel_loops
, value
);
2012 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tracer
, value
);
2013 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_value_profile_transformations
,
2015 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
2016 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp
, value
);
2019 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp_clone
, 1);
2020 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, 1);
2022 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_predictive_commoning
, value
);
2023 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_split_loops
, value
);
2024 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unswitch_loops
, value
);
2025 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_gcse_after_reload
, value
);
2026 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_vectorize
, value
);
2027 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_slp_vectorize
, value
);
2028 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_version_loops_for_strides
, value
);
2029 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_vect_cost_model
,
2030 VECT_COST_MODEL_DYNAMIC
);
2031 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribute_patterns
,
2033 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_loop_interchange
, value
);
2034 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_jam
, value
);
2035 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribution
, value
);
2038 /* -f{,no-}sanitize{,-recover}= suboptions. */
2039 const struct sanitizer_opts_s sanitizer_opts
[] =
2041 #define SANITIZER_OPT(name, flags, recover, trap) \
2042 { #name, flags, sizeof #name - 1, recover, trap }
2043 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true,
2045 SANITIZER_OPT (hwaddress
, (SANITIZE_HWADDRESS
| SANITIZE_USER_HWADDRESS
),
2047 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
2049 SANITIZER_OPT (kernel
-hwaddress
,
2050 (SANITIZE_HWADDRESS
| SANITIZE_KERNEL_HWADDRESS
),
2052 SANITIZER_OPT (pointer
-compare
, SANITIZE_POINTER_COMPARE
, true, false),
2053 SANITIZER_OPT (pointer
-subtract
, SANITIZE_POINTER_SUBTRACT
, true, false),
2054 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false, false),
2055 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false, false),
2056 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true, true),
2057 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true, true),
2058 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true, true),
2059 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true, true),
2060 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true, true),
2061 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false, true),
2062 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true, true),
2063 SANITIZER_OPT (return, SANITIZE_RETURN
, false, true),
2064 SANITIZER_OPT (null
, SANITIZE_NULL
, true, true),
2065 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true, true),
2066 SANITIZER_OPT (bool, SANITIZE_BOOL
, true, true),
2067 SANITIZER_OPT (enum, SANITIZE_ENUM
, true, true),
2068 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true, true),
2069 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true, true),
2070 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true, true),
2071 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true,
2073 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true, true),
2074 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true, true),
2075 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
2077 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true, true),
2078 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true, false),
2079 SANITIZER_OPT (pointer
-overflow
, SANITIZE_POINTER_OVERFLOW
, true, true),
2080 SANITIZER_OPT (builtin
, SANITIZE_BUILTIN
, true, true),
2081 SANITIZER_OPT (shadow
-call
-stack
, SANITIZE_SHADOW_CALL_STACK
, false, false),
2082 SANITIZER_OPT (all
, ~0U, true, true),
2083 #undef SANITIZER_OPT
2084 { NULL
, 0U, 0UL, false, false }
2087 /* -fzero-call-used-regs= suboptions. */
2088 const struct zero_call_used_regs_opts_s zero_call_used_regs_opts
[] =
2090 #define ZERO_CALL_USED_REGS_OPT(name, flags) \
2092 ZERO_CALL_USED_REGS_OPT (skip
, zero_regs_flags::SKIP
),
2093 ZERO_CALL_USED_REGS_OPT (used
-gpr
-arg
, zero_regs_flags::USED_GPR_ARG
),
2094 ZERO_CALL_USED_REGS_OPT (used
-gpr
, zero_regs_flags::USED_GPR
),
2095 ZERO_CALL_USED_REGS_OPT (used
-arg
, zero_regs_flags::USED_ARG
),
2096 ZERO_CALL_USED_REGS_OPT (used
, zero_regs_flags::USED
),
2097 ZERO_CALL_USED_REGS_OPT (all
-gpr
-arg
, zero_regs_flags::ALL_GPR_ARG
),
2098 ZERO_CALL_USED_REGS_OPT (all
-gpr
, zero_regs_flags::ALL_GPR
),
2099 ZERO_CALL_USED_REGS_OPT (all
-arg
, zero_regs_flags::ALL_ARG
),
2100 ZERO_CALL_USED_REGS_OPT (all
, zero_regs_flags::ALL
),
2101 #undef ZERO_CALL_USED_REGS_OPT
2105 /* A struct for describing a run of chars within a string. */
2107 class string_fragment
2110 string_fragment (const char *start
, size_t len
)
2111 : m_start (start
), m_len (len
) {}
2113 const char *m_start
;
2117 /* Specialization of edit_distance_traits for string_fragment,
2118 for use by get_closest_sanitizer_option. */
2121 struct edit_distance_traits
<const string_fragment
&>
2123 static size_t get_length (const string_fragment
&fragment
)
2125 return fragment
.m_len
;
2128 static const char *get_string (const string_fragment
&fragment
)
2130 return fragment
.m_start
;
2134 /* Given ARG, an unrecognized sanitizer option, return the best
2135 matching sanitizer option, or NULL if there isn't one.
2136 OPTS is array of candidate sanitizer options.
2137 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or OPT_fsanitize_trap_.
2138 VALUE is non-zero for the regular form of the option, zero
2139 for the "no-" form (e.g. "-fno-sanitize-recover="). */
2142 get_closest_sanitizer_option (const string_fragment
&arg
,
2143 const struct sanitizer_opts_s
*opts
,
2144 enum opt_code code
, int value
)
2146 best_match
<const string_fragment
&, const char*> bm (arg
);
2147 for (int i
= 0; opts
[i
].name
!= NULL
; ++i
)
2149 /* -fsanitize=all is not valid, so don't offer it. */
2150 if (code
== OPT_fsanitize_
2151 && opts
[i
].flag
== ~0U
2155 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
2156 don't offer the non-recoverable options. */
2157 if (code
== OPT_fsanitize_recover_
2158 && !opts
[i
].can_recover
2162 /* For -fsanitize-trap= (and not -fno-sanitize-trap=),
2163 don't offer the non-trapping options. */
2164 if (code
== OPT_fsanitize_trap_
2165 && !opts
[i
].can_trap
2169 bm
.consider (opts
[i
].name
);
2171 return bm
.get_best_meaningful_candidate ();
2174 /* Parse comma separated sanitizer suboptions from P for option SCODE,
2175 adjust previous FLAGS and return new ones. If COMPLAIN is false,
2176 don't issue diagnostics. */
2179 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
2180 unsigned int flags
, int value
, bool complain
)
2182 enum opt_code code
= (enum opt_code
) scode
;
2188 const char *comma
= strchr (p
, ',');
2200 /* Check to see if the string matches an option class name. */
2201 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
2202 if (len
== sanitizer_opts
[i
].len
2203 && memcmp (p
, sanitizer_opts
[i
].name
, len
) == 0)
2205 /* Handle both -fsanitize and -fno-sanitize cases. */
2206 if (value
&& sanitizer_opts
[i
].flag
== ~0U)
2208 if (code
== OPT_fsanitize_
)
2211 error_at (loc
, "%<-fsanitize=all%> option is not valid");
2213 else if (code
== OPT_fsanitize_recover_
)
2214 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
2215 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
2216 | SANITIZE_SHADOW_CALL_STACK
);
2217 else /* if (code == OPT_fsanitize_trap_) */
2218 flags
|= (SANITIZE_UNDEFINED
2219 | SANITIZE_UNDEFINED_NONDEFAULT
);
2223 /* Do not enable -fsanitize-recover=unreachable and
2224 -fsanitize-recover=return if -fsanitize-recover=undefined
2226 if (code
== OPT_fsanitize_recover_
2227 && sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
2228 flags
|= (SANITIZE_UNDEFINED
2229 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
2230 else if (code
== OPT_fsanitize_trap_
2231 && sanitizer_opts
[i
].flag
== SANITIZE_VPTR
)
2232 error_at (loc
, "%<-fsanitize-trap=%s%> is not supported",
2233 sanitizer_opts
[i
].name
);
2235 flags
|= sanitizer_opts
[i
].flag
;
2238 flags
&= ~sanitizer_opts
[i
].flag
;
2243 if (! found
&& complain
)
2246 = get_closest_sanitizer_option (string_fragment (p
, len
),
2247 sanitizer_opts
, code
, value
);
2250 if (code
== OPT_fsanitize_recover_
)
2251 suffix
= "-recover";
2252 else if (code
== OPT_fsanitize_trap_
)
2259 "unrecognized argument to %<-f%ssanitize%s=%> "
2260 "option: %q.*s; did you mean %qs?",
2262 suffix
, (int) len
, p
, hint
);
2265 "unrecognized argument to %<-f%ssanitize%s=%> option: "
2266 "%q.*s", value
? "" : "no-",
2267 suffix
, (int) len
, p
);
2277 /* Parse string values of no_sanitize attribute passed in VALUE.
2278 Values are separated with comma. */
2281 parse_no_sanitize_attribute (char *value
)
2283 unsigned int flags
= 0;
2285 char *q
= strtok (value
, ",");
2289 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
2290 if (strcmp (sanitizer_opts
[i
].name
, q
) == 0)
2292 flags
|= sanitizer_opts
[i
].flag
;
2293 if (sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
2294 flags
|= SANITIZE_UNDEFINED_NONDEFAULT
;
2298 if (sanitizer_opts
[i
].name
== NULL
)
2299 warning (OPT_Wattributes
,
2300 "%qs attribute directive ignored", q
);
2302 q
= strtok (NULL
, ",");
2308 /* Parse -fzero-call-used-regs suboptions from ARG, return the FLAGS. */
2311 parse_zero_call_used_regs_options (const char *arg
)
2313 unsigned int flags
= 0;
2315 /* Check to see if the string matches a sub-option name. */
2316 for (unsigned int i
= 0; zero_call_used_regs_opts
[i
].name
!= NULL
; ++i
)
2317 if (strcmp (arg
, zero_call_used_regs_opts
[i
].name
) == 0)
2319 flags
= zero_call_used_regs_opts
[i
].flag
;
2324 error ("unrecognized argument to %<-fzero-call-used-regs=%>: %qs", arg
);
2329 /* Parse -falign-NAME format for a FLAG value. Return individual
2330 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
2331 set, print error message at LOC location. */
2334 parse_and_check_align_values (const char *flag
,
2336 auto_vec
<unsigned> &result_values
,
2340 char *str
= xstrdup (flag
);
2341 for (char *p
= strtok (str
, ":"); p
; p
= strtok (NULL
, ":"))
2344 int v
= strtol (p
, &end
, 10);
2345 if (*end
!= '\0' || v
< 0)
2348 error_at (loc
, "invalid arguments for %<-falign-%s%> option: %qs",
2354 result_values
.safe_push ((unsigned)v
);
2359 /* Check that we have a correct number of values. */
2360 if (result_values
.is_empty () || result_values
.length () > 4)
2363 error_at (loc
, "invalid number of arguments for %<-falign-%s%> "
2364 "option: %qs", name
, flag
);
2368 for (unsigned i
= 0; i
< result_values
.length (); i
++)
2369 if (result_values
[i
] > MAX_CODE_ALIGN_VALUE
)
2372 error_at (loc
, "%<-falign-%s%> is not between 0 and %d",
2373 name
, MAX_CODE_ALIGN_VALUE
);
2380 /* Check that alignment value FLAG for -falign-NAME is valid at a given
2381 location LOC. OPT_STR points to the stored -falign-NAME=argument and
2382 OPT_FLAG points to the associated -falign-NAME on/off flag. */
2385 check_alignment_argument (location_t loc
, const char *flag
, const char *name
,
2386 int *opt_flag
, const char **opt_str
)
2388 auto_vec
<unsigned> align_result
;
2389 parse_and_check_align_values (flag
, name
, align_result
, true, loc
);
2391 if (align_result
.length() >= 1 && align_result
[0] == 0)
2398 /* Parse argument of -fpatchable-function-entry option ARG and store
2399 corresponding values to PATCH_AREA_SIZE and PATCH_AREA_START.
2400 If REPORT_ERROR is set to true, generate error for a problematic
2401 option arguments. */
2404 parse_and_check_patch_area (const char *arg
, bool report_error
,
2405 HOST_WIDE_INT
*patch_area_size
,
2406 HOST_WIDE_INT
*patch_area_start
)
2408 *patch_area_size
= 0;
2409 *patch_area_start
= 0;
2414 char *patch_area_arg
= xstrdup (arg
);
2415 char *comma
= strchr (patch_area_arg
, ',');
2419 *patch_area_size
= integral_argument (patch_area_arg
);
2420 *patch_area_start
= integral_argument (comma
+ 1);
2423 *patch_area_size
= integral_argument (patch_area_arg
);
2425 if (*patch_area_size
< 0
2426 || *patch_area_size
> USHRT_MAX
2427 || *patch_area_start
< 0
2428 || *patch_area_start
> USHRT_MAX
2429 || *patch_area_size
< *patch_area_start
)
2431 error ("invalid arguments for %<-fpatchable-function-entry%>");
2433 free (patch_area_arg
);
2436 /* Print help when OPT__help_ is set. */
2439 print_help (struct gcc_options
*opts
, unsigned int lang_mask
,
2440 const char *help_option_argument
)
2442 const char *a
= help_option_argument
;
2443 unsigned int include_flags
= 0;
2444 /* Note - by default we include undocumented options when listing
2445 specific classes. If you only want to see documented options
2446 then add ",^undocumented" to the --help= option. E.g.:
2448 --help=target,^undocumented */
2449 unsigned int exclude_flags
= 0;
2451 if (lang_mask
== CL_DRIVER
)
2454 /* Walk along the argument string, parsing each word in turn.
2456 arg = [^]{word}[,{arg}]
2457 word = {optimizers|target|warnings|undocumented|
2458 params|common|<language>} */
2468 { "optimizers", CL_OPTIMIZATION
},
2469 { "target", CL_TARGET
},
2470 { "warnings", CL_WARNING
},
2471 { "undocumented", CL_UNDOCUMENTED
},
2472 { "params", CL_PARAMS
},
2473 { "joined", CL_JOINED
},
2474 { "separate", CL_SEPARATE
},
2475 { "common", CL_COMMON
},
2478 unsigned int *pflags
;
2480 unsigned int lang_flag
, specific_flag
;
2489 error ("missing argument to %qs", "--help=^");
2492 pflags
= &exclude_flags
;
2495 pflags
= &include_flags
;
2497 comma
= strchr (a
, ',');
2508 /* Check to see if the string matches an option class name. */
2509 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
2510 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
2512 specific_flag
= specifics
[i
].flag
;
2516 /* Check to see if the string matches a language name.
2517 Note - we rely upon the alpha-sorted nature of the entries in
2518 the lang_names array, specifically that shorter names appear
2519 before their longer variants. (i.e. C before C++). That way
2520 when we are attempting to match --help=c for example we will
2521 match with C first and not C++. */
2522 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
2523 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
2525 lang_flag
= 1U << i
;
2529 if (specific_flag
!= 0)
2532 *pflags
|= specific_flag
;
2535 /* The option's argument matches both the start of a
2536 language name and the start of an option class name.
2537 We have a special case for when the user has
2538 specified "--help=c", but otherwise we have to issue
2540 if (strncasecmp (a
, "c", len
) == 0)
2541 *pflags
|= lang_flag
;
2544 "%<--help%> argument %q.*s is ambiguous, "
2545 "please be more specific",
2549 else if (lang_flag
!= 0)
2550 *pflags
|= lang_flag
;
2553 "unrecognized argument to %<--help=%> option: %q.*s",
2561 /* We started using PerFunction/Optimization for parameters and
2562 a warning. We should exclude these from optimization options. */
2563 if (include_flags
& CL_OPTIMIZATION
)
2564 exclude_flags
|= CL_WARNING
;
2565 if (!(include_flags
& CL_PARAMS
))
2566 exclude_flags
|= CL_PARAMS
;
2569 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
2573 /* Handle target- and language-independent options. Return zero to
2574 generate an "unknown option" message. Only options that need
2575 extra handling need to be listed here; if you simply want
2576 DECODED->value assigned to a variable, it happens automatically. */
2579 common_handle_option (struct gcc_options
*opts
,
2580 struct gcc_options
*opts_set
,
2581 const struct cl_decoded_option
*decoded
,
2582 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
2584 const struct cl_option_handlers
*handlers
,
2585 diagnostic_context
*dc
,
2586 void (*target_option_override_hook
) (void))
2588 size_t scode
= decoded
->opt_index
;
2589 const char *arg
= decoded
->arg
;
2590 HOST_WIDE_INT value
= decoded
->value
;
2591 enum opt_code code
= (enum opt_code
) scode
;
2593 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
2599 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
2600 unsigned int undoc_mask
;
2603 if (lang_mask
== CL_DRIVER
)
2606 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
2609 target_option_override_hook ();
2610 /* First display any single language specific options. */
2611 for (i
= 0; i
< cl_lang_count
; i
++)
2613 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
2615 /* Next display any multi language specific options. */
2616 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
2617 /* Then display any remaining, non-language options. */
2618 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
2620 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
2621 opts
->x_exit_after_options
= true;
2625 case OPT__target_help
:
2626 if (lang_mask
== CL_DRIVER
)
2629 target_option_override_hook ();
2630 print_specific_help (CL_TARGET
, 0, 0, opts
, lang_mask
);
2631 opts
->x_exit_after_options
= true;
2636 help_option_arguments
.safe_push (arg
);
2637 opts
->x_exit_after_options
= true;
2642 if (lang_mask
== CL_DRIVER
)
2645 opts
->x_exit_after_options
= true;
2648 case OPT__completion_
:
2651 case OPT_fsanitize_
:
2652 opts_set
->x_flag_sanitize
= true;
2653 opts
->x_flag_sanitize
2654 = parse_sanitizer_options (arg
, loc
, code
,
2655 opts
->x_flag_sanitize
, value
, true);
2657 /* Kernel ASan implies normal ASan but does not yet support
2659 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
2661 SET_OPTION_IF_UNSET (opts
, opts_set
,
2662 param_asan_instrumentation_with_call_threshold
,
2664 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_globals
, 0);
2665 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_stack
, 0);
2666 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_protect_allocas
, 0);
2667 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_use_after_return
, 0);
2669 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_HWADDRESS
)
2671 SET_OPTION_IF_UNSET (opts
, opts_set
,
2672 param_hwasan_instrument_stack
, 0);
2673 SET_OPTION_IF_UNSET (opts
, opts_set
,
2674 param_hwasan_random_frame_tag
, 0);
2675 SET_OPTION_IF_UNSET (opts
, opts_set
,
2676 param_hwasan_instrument_allocas
, 0);
2680 case OPT_fsanitize_recover_
:
2681 opts
->x_flag_sanitize_recover
2682 = parse_sanitizer_options (arg
, loc
, code
,
2683 opts
->x_flag_sanitize_recover
, value
, true);
2686 case OPT_fsanitize_trap_
:
2687 opts
->x_flag_sanitize_trap
2688 = parse_sanitizer_options (arg
, loc
, code
,
2689 opts
->x_flag_sanitize_trap
, value
, true);
2692 case OPT_fasan_shadow_offset_
:
2696 case OPT_fsanitize_address_use_after_scope
:
2697 opts
->x_flag_sanitize_address_use_after_scope
= value
;
2700 case OPT_fsanitize_recover
:
2702 opts
->x_flag_sanitize_recover
2703 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)
2704 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2706 opts
->x_flag_sanitize_recover
2707 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2710 case OPT_fsanitize_trap
:
2712 opts
->x_flag_sanitize_trap
2713 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2715 opts
->x_flag_sanitize_trap
2716 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2724 /* Currently handled in a prescan. */
2727 case OPT_Wattributes_
:
2728 if (lang_mask
== CL_DRIVER
)
2733 error_at (loc
, "arguments ignored for %<-Wattributes=%>; use "
2734 "%<-Wno-attributes=%> instead");
2737 else if (arg
[strlen (arg
) - 1] == ',')
2739 error_at (loc
, "trailing %<,%> in arguments for "
2740 "%<-Wno-attributes=%>");
2744 add_comma_separated_to_vector (&opts
->x_flag_ignored_attributes
, arg
);
2748 dc
->warning_as_error_requested
= value
;
2752 if (lang_mask
== CL_DRIVER
)
2755 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
2756 opts
, opts_set
, loc
, dc
);
2759 case OPT_Wfatal_errors
:
2760 dc
->fatal_errors
= value
;
2763 case OPT_Wstack_usage_
:
2764 opts
->x_flag_stack_usage_info
= value
!= -1;
2767 case OPT_Wstrict_aliasing
:
2768 set_Wstrict_aliasing (opts
, value
);
2771 case OPT_Wstrict_overflow
:
2772 opts
->x_warn_strict_overflow
= (value
2773 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2777 case OPT_Wsystem_headers
:
2778 dc
->dc_warn_system_headers
= value
;
2782 opts
->x_flag_gen_aux_info
= 1;
2786 decode_d_option (arg
, opts
, loc
, dc
);
2789 case OPT_fcall_used_
:
2790 case OPT_fcall_saved_
:
2798 case OPT_fdebug_prefix_map_
:
2799 case OPT_ffile_prefix_map_
:
2800 case OPT_fprofile_prefix_map_
:
2804 case OPT_fcallgraph_info
:
2805 opts
->x_flag_callgraph_info
= CALLGRAPH_INFO_NAKED
;
2808 case OPT_fcallgraph_info_
:
2811 my_arg
= xstrdup (arg
);
2812 p
= strtok (my_arg
, ",");
2815 if (strcmp (p
, "su") == 0)
2817 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_STACK_USAGE
;
2818 opts
->x_flag_stack_usage_info
= true;
2820 else if (strcmp (p
, "da") == 0)
2821 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_DYNAMIC_ALLOC
;
2824 p
= strtok (NULL
, ",");
2830 case OPT_fdiagnostics_show_location_
:
2831 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2834 case OPT_fdiagnostics_show_caret
:
2835 dc
->show_caret
= value
;
2838 case OPT_fdiagnostics_show_labels
:
2839 dc
->show_labels_p
= value
;
2842 case OPT_fdiagnostics_show_line_numbers
:
2843 dc
->show_line_numbers_p
= value
;
2846 case OPT_fdiagnostics_color_
:
2847 diagnostic_color_init (dc
, value
);
2850 case OPT_fdiagnostics_urls_
:
2851 diagnostic_urls_init (dc
, value
);
2854 case OPT_fdiagnostics_format_
:
2855 diagnostic_output_format_init (dc
, opts
->x_dump_base_name
,
2856 (enum diagnostics_output_format
)value
);
2859 case OPT_fdiagnostics_parseable_fixits
:
2860 dc
->extra_output_kind
= (value
2861 ? EXTRA_DIAGNOSTIC_OUTPUT_fixits_v1
2862 : EXTRA_DIAGNOSTIC_OUTPUT_none
);
2865 case OPT_fdiagnostics_column_unit_
:
2866 dc
->column_unit
= (enum diagnostics_column_unit
)value
;
2869 case OPT_fdiagnostics_column_origin_
:
2870 dc
->column_origin
= value
;
2873 case OPT_fdiagnostics_escape_format_
:
2874 dc
->escape_format
= (enum diagnostics_escape_format
)value
;
2877 case OPT_fdiagnostics_show_cwe
:
2878 dc
->show_cwe
= value
;
2881 case OPT_fdiagnostics_show_rules
:
2882 dc
->show_rules
= value
;
2885 case OPT_fdiagnostics_path_format_
:
2886 dc
->path_format
= (enum diagnostic_path_format
)value
;
2889 case OPT_fdiagnostics_show_path_depths
:
2890 dc
->show_path_depths
= value
;
2893 case OPT_fdiagnostics_show_option
:
2894 dc
->show_option_requested
= value
;
2897 case OPT_fdiagnostics_minimum_margin_width_
:
2898 dc
->min_margin_width
= value
;
2905 case OPT_ffast_math
:
2906 set_fast_math_flags (opts
, value
);
2909 case OPT_funsafe_math_optimizations
:
2910 set_unsafe_math_optimizations_flags (opts
, value
);
2917 case OPT_finline_limit_
:
2918 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_single
,
2920 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_auto
,
2924 case OPT_finstrument_functions_exclude_function_list_
:
2925 add_comma_separated_to_vector
2926 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2929 case OPT_finstrument_functions_exclude_file_list_
:
2930 add_comma_separated_to_vector
2931 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2934 case OPT_fmessage_length_
:
2935 pp_set_line_maximum_length (dc
->printer
, value
);
2936 diagnostic_set_caret_max_width (dc
, value
);
2940 case OPT_fopt_info_
:
2944 case OPT_foffload_options_
:
2948 case OPT_foffload_abi_
:
2949 #ifdef ACCEL_COMPILER
2950 /* Handled in the 'mkoffload's. */
2952 error_at (loc
, "%<-foffload-abi%> option can be specified only for "
2953 "offload compiler");
2957 case OPT_fpack_struct_
:
2958 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2960 "structure alignment must be a small power of two, not %wu",
2963 opts
->x_initial_max_fld_align
= value
;
2967 case OPT_fplugin_arg_
:
2971 case OPT_fprofile_use_
:
2972 opts
->x_profile_data_prefix
= xstrdup (arg
);
2973 opts
->x_flag_profile_use
= true;
2975 /* No break here - do -fprofile-use processing. */
2977 case OPT_fprofile_use
:
2978 enable_fdo_optimizations (opts
, opts_set
, value
);
2979 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_reorder_functions
,
2981 /* Indirect call profiling should do all useful transformations
2982 speculative devirtualization does. */
2983 if (opts
->x_flag_value_profile_transformations
)
2984 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_devirtualize_speculatively
,
2988 case OPT_fauto_profile_
:
2989 opts
->x_auto_profile_file
= xstrdup (arg
);
2990 opts
->x_flag_auto_profile
= true;
2992 /* No break here - do -fauto-profile processing. */
2994 case OPT_fauto_profile
:
2995 enable_fdo_optimizations (opts
, opts_set
, value
);
2996 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_correction
, value
);
2999 case OPT_fprofile_generate_
:
3000 opts
->x_profile_data_prefix
= xstrdup (arg
);
3002 /* No break here - do -fprofile-generate processing. */
3004 case OPT_fprofile_generate
:
3005 SET_OPTION_IF_UNSET (opts
, opts_set
, profile_arc_flag
, value
);
3006 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
3007 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
3008 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, value
);
3011 case OPT_fprofile_info_section
:
3012 opts
->x_profile_info_section
= ".gcov_info";
3015 case OPT_fpatchable_function_entry_
:
3017 HOST_WIDE_INT patch_area_size
, patch_area_start
;
3018 parse_and_check_patch_area (arg
, true, &patch_area_size
,
3023 case OPT_ftree_vectorize
:
3024 /* Automatically sets -ftree-loop-vectorize and
3025 -ftree-slp-vectorize. Nothing more to do here. */
3027 case OPT_fzero_call_used_regs_
:
3028 opts
->x_flag_zero_call_used_regs
3029 = parse_zero_call_used_regs_options (arg
);
3032 case OPT_fshow_column
:
3033 dc
->show_column
= value
;
3036 case OPT_frandom_seed
:
3037 /* The real switch is -fno-random-seed. */
3043 case OPT_frandom_seed_
:
3047 case OPT_fsched_verbose_
:
3048 #ifdef INSN_SCHEDULING
3049 /* Handled with Var in common.opt. */
3055 case OPT_fsched_stalled_insns_
:
3056 opts
->x_flag_sched_stalled_insns
= value
;
3057 if (opts
->x_flag_sched_stalled_insns
== 0)
3058 opts
->x_flag_sched_stalled_insns
= -1;
3061 case OPT_fsched_stalled_insns_dep_
:
3062 opts
->x_flag_sched_stalled_insns_dep
= value
;
3065 case OPT_fstack_check_
:
3066 if (!strcmp (arg
, "no"))
3067 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
3068 else if (!strcmp (arg
, "generic"))
3069 /* This is the old stack checking method. */
3070 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
3071 ? FULL_BUILTIN_STACK_CHECK
3072 : GENERIC_STACK_CHECK
;
3073 else if (!strcmp (arg
, "specific"))
3074 /* This is the new stack checking method. */
3075 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
3076 ? FULL_BUILTIN_STACK_CHECK
3077 : STACK_CHECK_STATIC_BUILTIN
3078 ? STATIC_BUILTIN_STACK_CHECK
3079 : GENERIC_STACK_CHECK
;
3081 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
3084 case OPT_fstack_limit
:
3085 /* The real switch is -fno-stack-limit. */
3091 case OPT_fstack_limit_register_
:
3092 case OPT_fstack_limit_symbol_
:
3096 case OPT_fstack_usage
:
3097 opts
->x_flag_stack_usage
= value
;
3098 opts
->x_flag_stack_usage_info
= value
!= 0;
3102 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
3107 set_debug_level (BTF_DEBUG
, false, arg
, opts
, opts_set
, loc
);
3108 /* set the debug level to level 2, but if already at level 3,
3110 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
3111 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3115 set_debug_level (CTF_DEBUG
, false, arg
, opts
, opts_set
, loc
);
3116 /* CTF generation feeds off DWARF dies. For optimal CTF, switch debug
3117 info level to 2. If off or at level 1, set it to level 2, but if
3118 already at level 3, don't lower it. */
3119 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
3120 && opts
->x_ctf_debug_info_level
> CTFINFO_LEVEL_NONE
)
3121 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3125 if (arg
&& strlen (arg
) != 0)
3127 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
3128 "use %<-gdwarf-%s%> for DWARF version "
3129 "or %<-gdwarf%> %<-g%s%> for debug level", arg
, arg
, arg
);
3133 value
= opts
->x_dwarf_version
;
3137 if (value
< 2 || value
> 5)
3138 error_at (loc
, "dwarf version %wu is not supported", value
);
3140 opts
->x_dwarf_version
= value
;
3141 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
3145 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
3149 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
3154 /* Handled completely via specs. */
3157 case OPT_pedantic_errors
:
3158 dc
->pedantic_errors
= 1;
3159 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
3161 handlers
, opts
, opts_set
,
3166 opts
->x_flag_lto
= value
? "" : NULL
;
3170 if (strcmp (arg
, "none") != 0
3171 && strcmp (arg
, "jobserver") != 0
3172 && strcmp (arg
, "auto") != 0
3175 "unrecognized argument to %<-flto=%> option: %qs", arg
);
3179 dc
->dc_inhibit_warnings
= true;
3182 case OPT_fmax_errors_
:
3183 dc
->max_errors
= value
;
3186 case OPT_fuse_ld_bfd
:
3187 case OPT_fuse_ld_gold
:
3188 case OPT_fuse_ld_lld
:
3189 case OPT_fuse_ld_mold
:
3190 case OPT_fuse_linker_plugin
:
3191 /* No-op. Used by the driver and passed to us because it starts with f.*/
3196 opts
->x_flag_trapv
= 0;
3201 opts
->x_flag_wrapv
= 0;
3204 case OPT_fstrict_overflow
:
3205 opts
->x_flag_wrapv
= !value
;
3206 opts
->x_flag_wrapv_pointer
= !value
;
3208 opts
->x_flag_trapv
= 0;
3212 opts
->x_flag_ipa_icf_functions
= value
;
3213 opts
->x_flag_ipa_icf_variables
= value
;
3216 case OPT_falign_loops_
:
3217 check_alignment_argument (loc
, arg
, "loops",
3218 &opts
->x_flag_align_loops
,
3219 &opts
->x_str_align_loops
);
3222 case OPT_falign_jumps_
:
3223 check_alignment_argument (loc
, arg
, "jumps",
3224 &opts
->x_flag_align_jumps
,
3225 &opts
->x_str_align_jumps
);
3228 case OPT_falign_labels_
:
3229 check_alignment_argument (loc
, arg
, "labels",
3230 &opts
->x_flag_align_labels
,
3231 &opts
->x_str_align_labels
);
3234 case OPT_falign_functions_
:
3235 check_alignment_argument (loc
, arg
, "functions",
3236 &opts
->x_flag_align_functions
,
3237 &opts
->x_str_align_functions
);
3241 /* It is documented that we silently ignore silly values. */
3242 if (value
>= 1 && value
<= 100)
3243 dc
->tabstop
= value
;
3246 case OPT_freport_bug
:
3247 dc
->report_bug
= value
;
3251 /* If the flag was handled in a standard way, assume the lack of
3252 processing here is intentional. */
3253 gcc_assert (option_flag_var (scode
, opts
));
3257 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
3262 /* Used to set the level of strict aliasing warnings in OPTS,
3263 when no level is specified (i.e., when -Wstrict-aliasing, and not
3264 -Wstrict-aliasing=level was given).
3265 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
3266 and 0 otherwise. After calling this function, wstrict_aliasing will be
3267 set to the default value of -Wstrict_aliasing=level, currently 3. */
3269 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
3271 gcc_assert (onoff
== 0 || onoff
== 1);
3273 opts
->x_warn_strict_aliasing
= 3;
3275 opts
->x_warn_strict_aliasing
= 0;
3278 /* The following routines are useful in setting all the flags that
3279 -ffast-math and -fno-fast-math imply. */
3281 set_fast_math_flags (struct gcc_options
*opts
, int set
)
3283 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
3285 opts
->x_flag_unsafe_math_optimizations
= set
;
3286 set_unsafe_math_optimizations_flags (opts
, set
);
3288 if (!opts
->frontend_set_flag_finite_math_only
)
3289 opts
->x_flag_finite_math_only
= set
;
3290 if (!opts
->frontend_set_flag_errno_math
)
3291 opts
->x_flag_errno_math
= !set
;
3294 if (opts
->frontend_set_flag_excess_precision
== EXCESS_PRECISION_DEFAULT
)
3295 opts
->x_flag_excess_precision
3296 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
3297 if (!opts
->frontend_set_flag_signaling_nans
)
3298 opts
->x_flag_signaling_nans
= 0;
3299 if (!opts
->frontend_set_flag_rounding_math
)
3300 opts
->x_flag_rounding_math
= 0;
3301 if (!opts
->frontend_set_flag_cx_limited_range
)
3302 opts
->x_flag_cx_limited_range
= 1;
3306 /* When -funsafe-math-optimizations is set the following
3307 flags are set as well. */
3309 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
3311 if (!opts
->frontend_set_flag_trapping_math
)
3312 opts
->x_flag_trapping_math
= !set
;
3313 if (!opts
->frontend_set_flag_signed_zeros
)
3314 opts
->x_flag_signed_zeros
= !set
;
3315 if (!opts
->frontend_set_flag_associative_math
)
3316 opts
->x_flag_associative_math
= set
;
3317 if (!opts
->frontend_set_flag_reciprocal_math
)
3318 opts
->x_flag_reciprocal_math
= set
;
3321 /* Return true iff flags in OPTS are set as if -ffast-math. */
3323 fast_math_flags_set_p (const struct gcc_options
*opts
)
3325 return (!opts
->x_flag_trapping_math
3326 && opts
->x_flag_unsafe_math_optimizations
3327 && opts
->x_flag_finite_math_only
3328 && !opts
->x_flag_signed_zeros
3329 && !opts
->x_flag_errno_math
3330 && opts
->x_flag_excess_precision
== EXCESS_PRECISION_FAST
);
3333 /* Return true iff flags are set as if -ffast-math but using the flags stored
3334 in the struct cl_optimization structure. */
3336 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
3338 return (!opt
->x_flag_trapping_math
3339 && opt
->x_flag_unsafe_math_optimizations
3340 && opt
->x_flag_finite_math_only
3341 && !opt
->x_flag_signed_zeros
3342 && !opt
->x_flag_errno_math
);
3345 /* Handle a debug output -g switch for options OPTS
3346 (OPTS_SET->x_write_symbols storing whether a debug format was passed
3347 explicitly), location LOC. EXTENDED is true or false to support
3348 extended output (2 is special and means "-ggdb" was given). */
3350 set_debug_level (uint32_t dinfo
, int extended
, const char *arg
,
3351 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
3354 if (dinfo
== NO_DEBUG
)
3356 if (opts
->x_write_symbols
== NO_DEBUG
)
3358 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
3362 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
3363 if (opts
->x_write_symbols
& CTF_DEBUG
)
3364 opts
->x_write_symbols
|= DWARF2_DEBUG
;
3366 opts
->x_write_symbols
= DWARF2_DEBUG
;
3370 if (opts
->x_write_symbols
== NO_DEBUG
)
3371 warning_at (loc
, 0, "target system does not support debug output");
3373 else if ((opts
->x_write_symbols
& CTF_DEBUG
)
3374 || (opts
->x_write_symbols
& BTF_DEBUG
))
3376 opts
->x_write_symbols
|= DWARF2_DEBUG
;
3377 opts_set
->x_write_symbols
|= DWARF2_DEBUG
;
3382 /* Make and retain the choice if both CTF and DWARF debug info are to
3384 if (((dinfo
== DWARF2_DEBUG
) || (dinfo
== CTF_DEBUG
))
3385 && ((opts
->x_write_symbols
== (DWARF2_DEBUG
|CTF_DEBUG
))
3386 || (opts
->x_write_symbols
== DWARF2_DEBUG
)
3387 || (opts
->x_write_symbols
== CTF_DEBUG
)))
3389 opts
->x_write_symbols
|= dinfo
;
3390 opts_set
->x_write_symbols
|= dinfo
;
3392 /* However, CTF and BTF are not allowed together at this time. */
3393 else if (((dinfo
== DWARF2_DEBUG
) || (dinfo
== BTF_DEBUG
))
3394 && ((opts
->x_write_symbols
== (DWARF2_DEBUG
|BTF_DEBUG
))
3395 || (opts
->x_write_symbols
== DWARF2_DEBUG
)
3396 || (opts
->x_write_symbols
== BTF_DEBUG
)))
3398 opts
->x_write_symbols
|= dinfo
;
3399 opts_set
->x_write_symbols
|= dinfo
;
3403 /* Does it conflict with an already selected debug format? */
3404 if (opts_set
->x_write_symbols
!= NO_DEBUG
3405 && opts
->x_write_symbols
!= NO_DEBUG
3406 && dinfo
!= opts
->x_write_symbols
)
3408 gcc_assert (debug_set_count (dinfo
) <= 1);
3409 error_at (loc
, "debug format %qs conflicts with prior selection",
3410 debug_type_names
[debug_set_to_format (dinfo
)]);
3412 opts
->x_write_symbols
= dinfo
;
3413 opts_set
->x_write_symbols
= dinfo
;
3417 if (dinfo
!= BTF_DEBUG
)
3419 /* A debug flag without a level defaults to level 2.
3420 If off or at level 1, set it to level 2, but if already
3421 at level 3, don't lower it. */
3424 if (dinfo
== CTF_DEBUG
)
3425 opts
->x_ctf_debug_info_level
= CTFINFO_LEVEL_NORMAL
;
3426 else if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
3427 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3431 int argval
= integral_argument (arg
);
3433 error_at (loc
, "unrecognized debug output level %qs", arg
);
3434 else if (argval
> 3)
3435 error_at (loc
, "debug output level %qs is too high", arg
);
3438 if (dinfo
== CTF_DEBUG
)
3439 opts
->x_ctf_debug_info_level
3440 = (enum ctf_debug_info_levels
) argval
;
3442 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
3446 else if (*arg
!= '\0')
3447 error_at (loc
, "unrecognized btf debug output level %qs", arg
);
3450 /* Arrange to dump core on error for diagnostic context DC. (The
3451 regular error message is still printed first, except in the case of
3455 setup_core_dumping (diagnostic_context
*dc
)
3458 signal (SIGABRT
, SIG_DFL
);
3460 #if defined(HAVE_SETRLIMIT)
3463 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
3464 fatal_error (input_location
, "getting core file size maximum limit: %m");
3465 rlim
.rlim_cur
= rlim
.rlim_max
;
3466 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
3467 fatal_error (input_location
,
3468 "setting core file size limit to maximum: %m");
3471 diagnostic_abort_on_error (dc
);
3474 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
3475 diagnostic context DC. */
3478 decode_d_option (const char *arg
, struct gcc_options
*opts
,
3479 location_t loc
, diagnostic_context
*dc
)
3487 opts
->x_flag_debug_asm
= 1;
3490 opts
->x_flag_print_asm_name
= 1;
3493 opts
->x_flag_dump_rtl_in_asm
= 1;
3494 opts
->x_flag_print_asm_name
= 1;
3497 opts
->x_rtl_dump_and_exit
= 1;
3499 case 'D': /* These are handled by the preprocessor. */
3506 setup_core_dumping (dc
);
3509 opts
->x_flag_dump_all_passed
= true;
3513 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
3518 /* Enable (or disable if VALUE is 0) a warning option ARG (language
3519 mask LANG_MASK, option handlers HANDLERS) as an error for option
3520 structures OPTS and OPTS_SET, diagnostic context DC (possibly
3521 NULL), location LOC. This is used by -Werror=. */
3524 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
3525 const struct cl_option_handlers
*handlers
,
3526 struct gcc_options
*opts
,
3527 struct gcc_options
*opts_set
,
3528 location_t loc
, diagnostic_context
*dc
)
3533 new_option
= XNEWVEC (char, strlen (arg
) + 2);
3534 new_option
[0] = 'W';
3535 strcpy (new_option
+ 1, arg
);
3536 option_index
= find_opt (new_option
, lang_mask
);
3537 if (option_index
== OPT_SPECIAL_unknown
)
3540 const char *hint
= op
.suggest_option (new_option
);
3542 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>;"
3543 " did you mean %<-%s%>?", value
? "" : "no-",
3544 arg
, new_option
, hint
);
3546 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>",
3547 value
? "" : "no-", arg
, new_option
);
3549 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
3550 error_at (loc
, "%<-Werror=%s%>: %<-%s%> is not an option that "
3551 "controls warnings", arg
, new_option
);
3554 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
3555 const char *arg
= NULL
;
3557 if (cl_options
[option_index
].flags
& CL_JOINED
)
3558 arg
= new_option
+ cl_options
[option_index
].opt_len
;
3559 control_warning_option (option_index
, (int) kind
, arg
, value
,
3561 handlers
, opts
, opts_set
, dc
);
3566 /* Return malloced memory for the name of the option OPTION_INDEX
3567 which enabled a diagnostic (context CONTEXT), originally of type
3568 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
3572 option_name (diagnostic_context
*context
, int option_index
,
3573 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
3577 /* A warning classified as an error. */
3578 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
3579 && diag_kind
== DK_ERROR
)
3580 return concat (cl_options
[OPT_Werror_
].opt_text
,
3581 /* Skip over "-W". */
3582 cl_options
[option_index
].opt_text
+ 2,
3584 /* A warning with option. */
3586 return xstrdup (cl_options
[option_index
].opt_text
);
3588 /* A warning without option classified as an error. */
3589 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
3590 || diag_kind
== DK_WARNING
)
3591 && context
->warning_as_error_requested
)
3592 return xstrdup (cl_options
[OPT_Werror
].opt_text
);
3597 /* Get the page within the documentation for this option. */
3600 get_option_html_page (int option_index
)
3602 const cl_option
*cl_opt
= &cl_options
[option_index
];
3604 /* Analyzer options are on their own page. */
3605 if (strstr (cl_opt
->opt_text
, "analyzer-"))
3606 return "gcc/Static-Analyzer-Options.html";
3608 /* Handle -flto= option. */
3609 if (strstr (cl_opt
->opt_text
, "flto"))
3610 return "gcc/Optimize-Options.html";
3613 if ((cl_opt
->flags
& CL_Fortran
) != 0
3614 /* If it is option common to both C/C++ and Fortran, it is documented
3615 in gcc/ rather than gfortran/ docs. */
3616 && (cl_opt
->flags
& CL_C
) == 0
3618 && (cl_opt
->flags
& CL_CXX
) == 0
3621 return "gfortran/Error-and-Warning-Options.html";
3624 return "gcc/Warning-Options.html";
3627 /* Return malloced memory for a URL describing the option OPTION_INDEX
3628 which enabled a diagnostic (context CONTEXT). */
3631 get_option_url (diagnostic_context
*, int option_index
)
3634 return concat (/* DOCUMENTATION_ROOT_URL should be supplied via -D by
3635 the Makefile (see --with-documentation-root-url), and
3636 should have a trailing slash. */
3637 DOCUMENTATION_ROOT_URL
,
3639 /* get_option_html_page will return something like
3640 "gcc/Warning-Options.html". */
3641 get_option_html_page (option_index
),
3643 /* Expect an anchor of the form "index-Wfoo" e.g.
3644 <a name="index-Wformat"></a>, and thus an id within
3645 the URL of "#index-Wformat". */
3646 "#index", cl_options
[option_index
].opt_text
,
3652 /* Return a heap allocated producer with command line options. */
3655 gen_command_line_string (cl_decoded_option
*options
,
3656 unsigned int options_count
)
3658 auto_vec
<const char *> switches
;
3659 char *options_string
, *tail
;
3663 for (unsigned i
= 0; i
< options_count
; i
++)
3664 switch (options
[i
].opt_index
)
3669 case OPT_dumpbase_ext
:
3679 case OPT_SPECIAL_unknown
:
3680 case OPT_SPECIAL_ignore
:
3681 case OPT_SPECIAL_warn_removed
:
3682 case OPT_SPECIAL_program_name
:
3683 case OPT_SPECIAL_input_file
:
3684 case OPT_grecord_gcc_switches
:
3685 case OPT_frecord_gcc_switches
:
3686 case OPT__output_pch
:
3687 case OPT_fdiagnostics_show_location_
:
3688 case OPT_fdiagnostics_show_option
:
3689 case OPT_fdiagnostics_show_caret
:
3690 case OPT_fdiagnostics_show_labels
:
3691 case OPT_fdiagnostics_show_line_numbers
:
3692 case OPT_fdiagnostics_color_
:
3693 case OPT_fdiagnostics_format_
:
3694 case OPT_fverbose_asm
:
3698 case OPT_nostdinc__
:
3699 case OPT_fpreprocessed
:
3700 case OPT_fltrans_output_list_
:
3701 case OPT_fresolution_
:
3702 case OPT_fdebug_prefix_map_
:
3703 case OPT_fmacro_prefix_map_
:
3704 case OPT_ffile_prefix_map_
:
3705 case OPT_fprofile_prefix_map_
:
3706 case OPT_fcompare_debug
:
3708 case OPT_fchecking_
:
3713 const char *lto_canonical
= "-flto";
3714 switches
.safe_push (lto_canonical
);
3715 len
+= strlen (lto_canonical
) + 1;
3719 if (cl_options
[options
[i
].opt_index
].flags
3720 & CL_NO_DWARF_RECORD
)
3722 gcc_checking_assert (options
[i
].canonical_option
[0][0] == '-');
3723 switch (options
[i
].canonical_option
[0][1])
3730 if (strncmp (options
[i
].canonical_option
[0] + 2,
3737 switches
.safe_push (options
[i
].orig_option_with_args_text
);
3738 len
+= strlen (options
[i
].orig_option_with_args_text
) + 1;
3742 options_string
= XNEWVEC (char, len
+ 1);
3743 tail
= options_string
;
3746 FOR_EACH_VEC_ELT (switches
, i
, p
)
3749 memcpy (tail
, p
, len
);
3751 if (i
!= switches
.length () - 1)
3759 return options_string
;
3762 /* Return a heap allocated producer string including command line options. */
3765 gen_producer_string (const char *language_string
, cl_decoded_option
*options
,
3766 unsigned int options_count
)
3768 char *cmdline
= gen_command_line_string (options
, options_count
);
3769 char *combined
= concat (language_string
, " ", version_string
, " ",
3777 namespace selftest
{
3779 /* Verify that get_option_html_page works as expected. */
3782 test_get_option_html_page ()
3784 ASSERT_STREQ (get_option_html_page (OPT_Wcpp
), "gcc/Warning-Options.html");
3785 ASSERT_STREQ (get_option_html_page (OPT_Wanalyzer_double_free
),
3786 "gcc/Static-Analyzer-Options.html");
3788 ASSERT_STREQ (get_option_html_page (OPT_Wline_truncation
),
3789 "gfortran/Error-and-Warning-Options.html");
3793 /* Verify EnumSet and EnumBitSet requirements. */
3798 for (unsigned i
= 0; i
< cl_options_count
; ++i
)
3799 if (cl_options
[i
].var_type
== CLVC_ENUM
3800 && cl_options
[i
].var_value
!= CLEV_NORMAL
)
3802 const struct cl_enum
*e
= &cl_enums
[cl_options
[i
].var_enum
];
3803 unsigned HOST_WIDE_INT used_sets
= 0;
3804 unsigned HOST_WIDE_INT mask
= 0;
3805 unsigned highest_set
= 0;
3806 for (unsigned j
= 0; e
->values
[j
].arg
; ++j
)
3808 unsigned set
= e
->values
[j
].flags
>> CL_ENUM_SET_SHIFT
;
3809 if (cl_options
[i
].var_value
== CLEV_BITSET
)
3811 /* For EnumBitSet Set shouldn't be used and Value should
3812 be a power of two. */
3813 ASSERT_TRUE (set
== 0);
3814 ASSERT_TRUE (pow2p_hwi (e
->values
[j
].value
));
3817 /* Test that enumerators referenced in EnumSet have all
3818 Set(n) on them within the valid range. */
3819 ASSERT_TRUE (set
>= 1 && set
<= HOST_BITS_PER_WIDE_INT
);
3820 highest_set
= MAX (set
, highest_set
);
3821 used_sets
|= HOST_WIDE_INT_1U
<< (set
- 1);
3823 if (cl_options
[i
].var_value
== CLEV_BITSET
)
3825 /* If there is just one set, no point to using EnumSet. */
3826 ASSERT_TRUE (highest_set
>= 2);
3827 /* Test that there are no gaps in between the sets. */
3828 if (highest_set
== HOST_BITS_PER_WIDE_INT
)
3829 ASSERT_TRUE (used_sets
== HOST_WIDE_INT_M1U
);
3831 ASSERT_TRUE (used_sets
== (HOST_WIDE_INT_1U
<< highest_set
) - 1);
3832 for (unsigned int j
= 1; j
<= highest_set
; ++j
)
3834 unsigned HOST_WIDE_INT this_mask
= 0;
3835 for (unsigned k
= 0; e
->values
[k
].arg
; ++k
)
3837 unsigned set
= e
->values
[j
].flags
>> CL_ENUM_SET_SHIFT
;
3839 this_mask
|= e
->values
[j
].value
;
3841 ASSERT_TRUE ((mask
& this_mask
) == 0);
3847 /* Run all of the selftests within this file. */
3852 test_get_option_html_page ();
3856 } // namespace selftest
3858 #endif /* #if CHECKING_P */