1 /* Command line option handling.
2 Copyright (C) 2002-2021 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 static void set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
);
40 /* Names of fundamental debug info formats indexed by enum
43 const char *const debug_type_names
[] =
45 "none", "stabs", "dwarf-2", "xcoff", "vms"
48 /* Bitmasks of fundamental debug info formats indexed by enum
51 static uint32_t debug_type_masks
[] =
53 NO_DEBUG
, DBX_DEBUG
, DWARF2_DEBUG
, XCOFF_DEBUG
, VMS_DEBUG
56 /* Names of the set of debug formats requested by user. Updated and accessed
57 via debug_set_names. */
59 static char df_set_names
[sizeof "none stabs dwarf-2 xcoff vms"];
61 /* Get enum debug_info_type of the specified debug format, for error messages.
62 Can be used only for individual debug format types. */
65 debug_set_to_format (uint32_t debug_info_set
)
68 enum debug_info_type dinfo_type
= DINFO_TYPE_NONE
;
69 /* Find first set bit. */
71 idx
= exact_log2 (debug_info_set
& - debug_info_set
);
72 /* Check that only one bit is set, if at all. This function is meant to be
73 used only for vanilla debug_info_set bitmask values, i.e. for individual
74 debug format types upto DINFO_TYPE_MAX. */
75 gcc_assert ((debug_info_set
& (debug_info_set
- 1)) == 0);
76 dinfo_type
= (enum debug_info_type
)idx
;
77 gcc_assert (dinfo_type
<= DINFO_TYPE_MAX
);
81 /* Get the number of debug formats enabled for output. */
84 debug_set_count (uint32_t w_symbols
)
86 unsigned int count
= 0;
90 w_symbols
&= ~ (w_symbols
& - w_symbols
);
95 /* Get the names of the debug formats enabled for output. */
98 debug_set_names (uint32_t w_symbols
)
100 uint32_t df_mask
= 0;
101 /* Reset the string to be returned. */
102 memset (df_set_names
, 0, sizeof (df_set_names
));
103 /* Get the popcount. */
104 int num_set_df
= debug_set_count (w_symbols
);
105 /* Iterate over the debug formats. Add name string for those enabled. */
106 for (int i
= DINFO_TYPE_NONE
; i
<= DINFO_TYPE_MAX
; i
++)
108 df_mask
= debug_type_masks
[i
];
109 if (w_symbols
& df_mask
)
111 strcat (df_set_names
, debug_type_names
[i
]);
114 strcat (df_set_names
, " ");
120 /* No debug formats enabled. */
121 gcc_assert (i
== DINFO_TYPE_NONE
);
122 strcat (df_set_names
, debug_type_names
[i
]);
129 /* Return TRUE iff dwarf2 debug info is enabled. */
134 return (write_symbols
& DWARF2_DEBUG
);
137 /* Parse the -femit-struct-debug-detailed option value
138 and set the flag variables. */
140 #define MATCH( prefix, string ) \
141 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
142 ? ((string += sizeof prefix - 1), 1) : 0)
145 set_struct_debug_option (struct gcc_options
*opts
, location_t loc
,
148 /* various labels for comparison */
149 static const char dfn_lbl
[] = "dfn:", dir_lbl
[] = "dir:", ind_lbl
[] = "ind:";
150 static const char ord_lbl
[] = "ord:", gen_lbl
[] = "gen:";
151 static const char none_lbl
[] = "none", any_lbl
[] = "any";
152 static const char base_lbl
[] = "base", sys_lbl
[] = "sys";
154 enum debug_struct_file files
= DINFO_STRUCT_FILE_ANY
;
155 /* Default is to apply to as much as possible. */
156 enum debug_info_usage usage
= DINFO_USAGE_NUM_ENUMS
;
157 int ord
= 1, gen
= 1;
160 if (MATCH (dfn_lbl
, spec
))
161 usage
= DINFO_USAGE_DFN
;
162 else if (MATCH (dir_lbl
, spec
))
163 usage
= DINFO_USAGE_DIR_USE
;
164 else if (MATCH (ind_lbl
, spec
))
165 usage
= DINFO_USAGE_IND_USE
;
167 /* Generics or not? */
168 if (MATCH (ord_lbl
, spec
))
170 else if (MATCH (gen_lbl
, spec
))
173 /* What allowable environment? */
174 if (MATCH (none_lbl
, spec
))
175 files
= DINFO_STRUCT_FILE_NONE
;
176 else if (MATCH (any_lbl
, spec
))
177 files
= DINFO_STRUCT_FILE_ANY
;
178 else if (MATCH (sys_lbl
, spec
))
179 files
= DINFO_STRUCT_FILE_SYS
;
180 else if (MATCH (base_lbl
, spec
))
181 files
= DINFO_STRUCT_FILE_BASE
;
184 "argument %qs to %<-femit-struct-debug-detailed%> "
188 /* Effect the specification. */
189 if (usage
== DINFO_USAGE_NUM_ENUMS
)
193 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DFN
] = files
;
194 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
] = files
;
195 opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
] = files
;
199 opts
->x_debug_struct_generic
[DINFO_USAGE_DFN
] = files
;
200 opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
] = files
;
201 opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
] = files
;
207 opts
->x_debug_struct_ordinary
[usage
] = files
;
209 opts
->x_debug_struct_generic
[usage
] = files
;
213 set_struct_debug_option (opts
, loc
, spec
+1);
216 /* No more -femit-struct-debug-detailed specifications.
220 "argument %qs to %<-femit-struct-debug-detailed%> unknown",
222 if (opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
]
223 < opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
]
224 || opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
]
225 < opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
])
227 "%<-femit-struct-debug-detailed=dir:...%> must allow "
228 "at least as much as "
229 "%<-femit-struct-debug-detailed=ind:...%>");
233 /* Strip off a legitimate source ending from the input string NAME of
234 length LEN. Rather than having to know the names used by all of
235 our front ends, we strip off an ending of a period followed by
236 up to fource characters. (C++ uses ".cpp".) */
239 strip_off_ending (char *name
, int len
)
242 for (i
= 2; i
< 5 && len
> i
; i
++)
244 if (name
[len
- i
] == '.')
246 name
[len
- i
] = '\0';
252 /* Find the base name of a path, stripping off both directories and
253 a single final extension. */
255 base_of_path (const char *path
, const char **base_out
)
257 const char *base
= path
;
259 const char *p
= path
;
263 if (IS_DIR_SEPARATOR (c
))
278 /* What to print when a switch has no documentation. */
279 static const char undocumented_msg
[] = N_("This option lacks documentation.");
280 static const char use_diagnosed_msg
[] = N_("Uses of this option are diagnosed.");
282 typedef char *char_p
; /* For DEF_VEC_P. */
284 static void set_debug_level (uint32_t dinfo
, int extended
,
285 const char *arg
, struct gcc_options
*opts
,
286 struct gcc_options
*opts_set
,
288 static void set_fast_math_flags (struct gcc_options
*opts
, int set
);
289 static void decode_d_option (const char *arg
, struct gcc_options
*opts
,
290 location_t loc
, diagnostic_context
*dc
);
291 static void set_unsafe_math_optimizations_flags (struct gcc_options
*opts
,
293 static void enable_warning_as_error (const char *arg
, int value
,
294 unsigned int lang_mask
,
295 const struct cl_option_handlers
*handlers
,
296 struct gcc_options
*opts
,
297 struct gcc_options
*opts_set
,
299 diagnostic_context
*dc
);
301 /* Handle a back-end option; arguments and return value as for
305 target_handle_option (struct gcc_options
*opts
,
306 struct gcc_options
*opts_set
,
307 const struct cl_decoded_option
*decoded
,
308 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
310 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
311 diagnostic_context
*dc
, void (*) (void))
313 gcc_assert (dc
== global_dc
);
314 gcc_assert (kind
== DK_UNSPECIFIED
);
315 return targetm_common
.handle_option (opts
, opts_set
, decoded
, loc
);
318 /* Add comma-separated strings to a char_p vector. */
321 add_comma_separated_to_vector (void **pvec
, const char *arg
)
327 vec
<char_p
> *v
= (vec
<char_p
> *) *pvec
;
329 vec_check_alloc (v
, 1);
331 /* We never free this string. */
344 v
->safe_push (token_start
);
347 if (*r
== '\\' && r
[1] == ',')
357 if (*token_start
!= '\0')
358 v
->safe_push (token_start
);
363 /* Initialize opts_obstack. */
366 init_opts_obstack (void)
368 gcc_obstack_init (&opts_obstack
);
371 /* Initialize OPTS and OPTS_SET before using them in parsing options. */
374 init_options_struct (struct gcc_options
*opts
, struct gcc_options
*opts_set
)
376 /* Ensure that opts_obstack has already been initialized by the time
377 that we initialize any gcc_options instances (PR jit/68446). */
378 gcc_assert (opts_obstack
.chunk_size
> 0);
380 *opts
= global_options_init
;
383 memset (opts_set
, 0, sizeof (*opts_set
));
385 /* Initialize whether `char' is signed. */
386 opts
->x_flag_signed_char
= DEFAULT_SIGNED_CHAR
;
387 /* Set this to a special "uninitialized" value. The actual default
388 is set after target options have been processed. */
389 opts
->x_flag_short_enums
= 2;
391 /* Initialize target_flags before default_options_optimization
392 so the latter can modify it. */
393 opts
->x_target_flags
= targetm_common
.default_target_flags
;
395 /* Some targets have ABI-specified unwind tables. */
396 opts
->x_flag_unwind_tables
= targetm_common
.unwind_tables_default
;
398 /* Some targets have other target-specific initialization. */
399 targetm_common
.option_init_struct (opts
);
402 /* If indicated by the optimization level LEVEL (-Os if SIZE is set,
403 -Ofast if FAST is set, -Og if DEBUG is set), apply the option DEFAULT_OPT
404 to OPTS and OPTS_SET, diagnostic context DC, location LOC, with language
405 mask LANG_MASK and option handlers HANDLERS. */
408 maybe_default_option (struct gcc_options
*opts
,
409 struct gcc_options
*opts_set
,
410 const struct default_options
*default_opt
,
411 int level
, bool size
, bool fast
, bool debug
,
412 unsigned int lang_mask
,
413 const struct cl_option_handlers
*handlers
,
415 diagnostic_context
*dc
)
417 const struct cl_option
*option
= &cl_options
[default_opt
->opt_index
];
421 gcc_assert (level
== 2);
423 gcc_assert (level
== 3);
425 gcc_assert (level
== 1);
427 switch (default_opt
->levels
)
433 case OPT_LEVELS_0_ONLY
:
434 enabled
= (level
== 0);
437 case OPT_LEVELS_1_PLUS
:
438 enabled
= (level
>= 1);
441 case OPT_LEVELS_1_PLUS_SPEED_ONLY
:
442 enabled
= (level
>= 1 && !size
&& !debug
);
445 case OPT_LEVELS_1_PLUS_NOT_DEBUG
:
446 enabled
= (level
>= 1 && !debug
);
449 case OPT_LEVELS_2_PLUS
:
450 enabled
= (level
>= 2);
453 case OPT_LEVELS_2_PLUS_SPEED_ONLY
:
454 enabled
= (level
>= 2 && !size
&& !debug
);
457 case OPT_LEVELS_3_PLUS
:
458 enabled
= (level
>= 3);
461 case OPT_LEVELS_3_PLUS_AND_SIZE
:
462 enabled
= (level
>= 3 || size
);
465 case OPT_LEVELS_SIZE
:
469 case OPT_LEVELS_FAST
:
473 case OPT_LEVELS_NONE
:
479 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
480 default_opt
->arg
, default_opt
->value
,
481 lang_mask
, DK_UNSPECIFIED
, loc
,
483 else if (default_opt
->arg
== NULL
484 && !option
->cl_reject_negative
485 && !(option
->flags
& CL_PARAMS
))
486 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
487 default_opt
->arg
, !default_opt
->value
,
488 lang_mask
, DK_UNSPECIFIED
, loc
,
492 /* As indicated by the optimization level LEVEL (-Os if SIZE is set,
493 -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
494 OPTS and OPTS_SET, diagnostic context DC, location LOC, with
495 language mask LANG_MASK and option handlers HANDLERS. */
498 maybe_default_options (struct gcc_options
*opts
,
499 struct gcc_options
*opts_set
,
500 const struct default_options
*default_opts
,
501 int level
, bool size
, bool fast
, bool debug
,
502 unsigned int lang_mask
,
503 const struct cl_option_handlers
*handlers
,
505 diagnostic_context
*dc
)
509 for (i
= 0; default_opts
[i
].levels
!= OPT_LEVELS_NONE
; i
++)
510 maybe_default_option (opts
, opts_set
, &default_opts
[i
],
511 level
, size
, fast
, debug
,
512 lang_mask
, handlers
, loc
, dc
);
515 /* Table of options enabled by default at different levels.
516 Please keep this list sorted by level and alphabetized within
517 each level; this makes it easier to keep the documentation
520 static const struct default_options default_options_table
[] =
522 /* -O1 and -Og optimizations. */
523 { OPT_LEVELS_1_PLUS
, OPT_fcombine_stack_adjustments
, NULL
, 1 },
524 { OPT_LEVELS_1_PLUS
, OPT_fcompare_elim
, NULL
, 1 },
525 { OPT_LEVELS_1_PLUS
, OPT_fcprop_registers
, NULL
, 1 },
526 { OPT_LEVELS_1_PLUS
, OPT_fdefer_pop
, NULL
, 1 },
527 { OPT_LEVELS_1_PLUS
, OPT_fforward_propagate
, NULL
, 1 },
528 { OPT_LEVELS_1_PLUS
, OPT_fguess_branch_probability
, NULL
, 1 },
529 { OPT_LEVELS_1_PLUS
, OPT_fipa_profile
, NULL
, 1 },
530 { OPT_LEVELS_1_PLUS
, OPT_fipa_pure_const
, NULL
, 1 },
531 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference
, NULL
, 1 },
532 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference_addressable
, NULL
, 1 },
533 { OPT_LEVELS_1_PLUS
, OPT_fmerge_constants
, NULL
, 1 },
534 { OPT_LEVELS_1_PLUS
, OPT_fomit_frame_pointer
, NULL
, 1 },
535 { OPT_LEVELS_1_PLUS
, OPT_freorder_blocks
, NULL
, 1 },
536 { OPT_LEVELS_1_PLUS
, OPT_fshrink_wrap
, NULL
, 1 },
537 { OPT_LEVELS_1_PLUS
, OPT_fsplit_wide_types
, NULL
, 1 },
538 { OPT_LEVELS_1_PLUS
, OPT_ftree_builtin_call_dce
, NULL
, 1 },
539 { OPT_LEVELS_1_PLUS
, OPT_ftree_ccp
, NULL
, 1 },
540 { OPT_LEVELS_1_PLUS
, OPT_ftree_ch
, NULL
, 1 },
541 { OPT_LEVELS_1_PLUS
, OPT_ftree_coalesce_vars
, NULL
, 1 },
542 { OPT_LEVELS_1_PLUS
, OPT_ftree_copy_prop
, NULL
, 1 },
543 { OPT_LEVELS_1_PLUS
, OPT_ftree_dce
, NULL
, 1 },
544 { OPT_LEVELS_1_PLUS
, OPT_ftree_dominator_opts
, NULL
, 1 },
545 { OPT_LEVELS_1_PLUS
, OPT_ftree_fre
, NULL
, 1 },
546 { OPT_LEVELS_1_PLUS
, OPT_ftree_sink
, NULL
, 1 },
547 { OPT_LEVELS_1_PLUS
, OPT_ftree_slsr
, NULL
, 1 },
548 { OPT_LEVELS_1_PLUS
, OPT_ftree_ter
, NULL
, 1 },
550 /* -O1 (and not -Og) optimizations. */
551 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fbranch_count_reg
, NULL
, 1 },
553 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fdelayed_branch
, NULL
, 1 },
555 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fdse
, NULL
, 1 },
556 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion
, NULL
, 1 },
557 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion2
, NULL
, 1 },
558 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_finline_functions_called_once
, NULL
, 1 },
559 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_invariants
, NULL
, 1 },
560 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fssa_phiopt
, NULL
, 1 },
561 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fipa_modref
, NULL
, 1 },
562 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_bit_ccp
, NULL
, 1 },
563 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_dse
, NULL
, 1 },
564 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_pta
, NULL
, 1 },
565 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_sra
, NULL
, 1 },
567 /* -O2 and -Os optimizations. */
568 { OPT_LEVELS_2_PLUS
, OPT_fcaller_saves
, NULL
, 1 },
569 { OPT_LEVELS_2_PLUS
, OPT_fcode_hoisting
, NULL
, 1 },
570 { OPT_LEVELS_2_PLUS
, OPT_fcrossjumping
, NULL
, 1 },
571 { OPT_LEVELS_2_PLUS
, OPT_fcse_follow_jumps
, NULL
, 1 },
572 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize
, NULL
, 1 },
573 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize_speculatively
, NULL
, 1 },
574 { OPT_LEVELS_2_PLUS
, OPT_fexpensive_optimizations
, NULL
, 1 },
575 { OPT_LEVELS_2_PLUS
, OPT_fgcse
, NULL
, 1 },
576 { OPT_LEVELS_2_PLUS
, OPT_fhoist_adjacent_loads
, NULL
, 1 },
577 { OPT_LEVELS_2_PLUS
, OPT_findirect_inlining
, NULL
, 1 },
578 { OPT_LEVELS_2_PLUS
, OPT_finline_small_functions
, NULL
, 1 },
579 { OPT_LEVELS_2_PLUS
, OPT_fipa_bit_cp
, NULL
, 1 },
580 { OPT_LEVELS_2_PLUS
, OPT_fipa_cp
, NULL
, 1 },
581 { OPT_LEVELS_2_PLUS
, OPT_fipa_icf
, NULL
, 1 },
582 { OPT_LEVELS_2_PLUS
, OPT_fipa_ra
, NULL
, 1 },
583 { OPT_LEVELS_2_PLUS
, OPT_fipa_sra
, NULL
, 1 },
584 { OPT_LEVELS_2_PLUS
, OPT_fipa_vrp
, NULL
, 1 },
585 { OPT_LEVELS_2_PLUS
, OPT_fisolate_erroneous_paths_dereference
, NULL
, 1 },
586 { OPT_LEVELS_2_PLUS
, OPT_flra_remat
, NULL
, 1 },
587 { OPT_LEVELS_2_PLUS
, OPT_foptimize_sibling_calls
, NULL
, 1 },
588 { OPT_LEVELS_2_PLUS
, OPT_fpartial_inlining
, NULL
, 1 },
589 { OPT_LEVELS_2_PLUS
, OPT_fpeephole2
, NULL
, 1 },
590 { OPT_LEVELS_2_PLUS
, OPT_freorder_functions
, NULL
, 1 },
591 { OPT_LEVELS_2_PLUS
, OPT_frerun_cse_after_loop
, NULL
, 1 },
592 #ifdef INSN_SCHEDULING
593 { OPT_LEVELS_2_PLUS
, OPT_fschedule_insns2
, NULL
, 1 },
595 { OPT_LEVELS_2_PLUS
, OPT_fstrict_aliasing
, NULL
, 1 },
596 { OPT_LEVELS_2_PLUS
, OPT_fstore_merging
, NULL
, 1 },
597 { OPT_LEVELS_2_PLUS
, OPT_fthread_jumps
, NULL
, 1 },
598 { OPT_LEVELS_2_PLUS
, OPT_ftree_pre
, NULL
, 1 },
599 { OPT_LEVELS_2_PLUS
, OPT_ftree_switch_conversion
, NULL
, 1 },
600 { OPT_LEVELS_2_PLUS
, OPT_ftree_tail_merge
, NULL
, 1 },
601 { OPT_LEVELS_2_PLUS
, OPT_ftree_vrp
, NULL
, 1 },
602 { OPT_LEVELS_2_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_CHEAP
},
603 { OPT_LEVELS_2_PLUS
, OPT_finline_functions
, NULL
, 1 },
604 { OPT_LEVELS_2_PLUS
, OPT_ftree_loop_distribute_patterns
, NULL
, 1 },
606 /* -O2 and above optimizations, but not -Os or -Og. */
607 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_functions
, NULL
, 1 },
608 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_jumps
, NULL
, 1 },
609 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_labels
, NULL
, 1 },
610 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_loops
, NULL
, 1 },
611 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_foptimize_strlen
, NULL
, 1 },
612 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_freorder_blocks_algorithm_
, NULL
,
613 REORDER_BLOCKS_ALGORITHM_STC
},
614 #ifdef INSN_SCHEDULING
615 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
616 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_fschedule_insns
, NULL
, 1 },
619 /* -O3 and -Os optimizations. */
621 /* -O3 optimizations. */
622 { OPT_LEVELS_3_PLUS
, OPT_fgcse_after_reload
, NULL
, 1 },
623 { OPT_LEVELS_3_PLUS
, OPT_fipa_cp_clone
, NULL
, 1 },
624 { OPT_LEVELS_3_PLUS
, OPT_floop_interchange
, NULL
, 1 },
625 { OPT_LEVELS_3_PLUS
, OPT_floop_unroll_and_jam
, NULL
, 1 },
626 { OPT_LEVELS_3_PLUS
, OPT_fpeel_loops
, NULL
, 1 },
627 { OPT_LEVELS_3_PLUS
, OPT_fpredictive_commoning
, NULL
, 1 },
628 { OPT_LEVELS_3_PLUS
, OPT_fsplit_loops
, NULL
, 1 },
629 { OPT_LEVELS_3_PLUS
, OPT_fsplit_paths
, NULL
, 1 },
630 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribution
, NULL
, 1 },
631 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_vectorize
, NULL
, 1 },
632 { OPT_LEVELS_3_PLUS
, OPT_ftree_partial_pre
, NULL
, 1 },
633 { OPT_LEVELS_3_PLUS
, OPT_ftree_slp_vectorize
, NULL
, 1 },
634 { OPT_LEVELS_3_PLUS
, OPT_funswitch_loops
, NULL
, 1 },
635 { OPT_LEVELS_3_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_DYNAMIC
},
636 { OPT_LEVELS_3_PLUS
, OPT_fversion_loops_for_strides
, NULL
, 1 },
638 /* -O3 parameters. */
639 { OPT_LEVELS_3_PLUS
, OPT__param_max_inline_insns_auto_
, NULL
, 30 },
640 { OPT_LEVELS_3_PLUS
, OPT__param_early_inlining_insns_
, NULL
, 14 },
641 { OPT_LEVELS_3_PLUS
, OPT__param_inline_heuristics_hint_percent_
, NULL
, 600 },
642 { OPT_LEVELS_3_PLUS
, OPT__param_inline_min_speedup_
, NULL
, 15 },
643 { OPT_LEVELS_3_PLUS
, OPT__param_max_inline_insns_single_
, NULL
, 200 },
645 /* -Ofast adds optimizations to -O3. */
646 { OPT_LEVELS_FAST
, OPT_ffast_math
, NULL
, 1 },
647 { OPT_LEVELS_FAST
, OPT_fallow_store_data_races
, NULL
, 1 },
649 { OPT_LEVELS_NONE
, 0, NULL
, 0 }
652 /* Default the options in OPTS and OPTS_SET based on the optimization
653 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
655 default_options_optimization (struct gcc_options
*opts
,
656 struct gcc_options
*opts_set
,
657 struct cl_decoded_option
*decoded_options
,
658 unsigned int decoded_options_count
,
660 unsigned int lang_mask
,
661 const struct cl_option_handlers
*handlers
,
662 diagnostic_context
*dc
)
666 bool openacc_mode
= false;
668 /* Scan to see what optimization level has been specified. That will
669 determine the default value of many flags. */
670 for (i
= 1; i
< decoded_options_count
; i
++)
672 struct cl_decoded_option
*opt
= &decoded_options
[i
];
673 switch (opt
->opt_index
)
676 if (*opt
->arg
== '\0')
678 opts
->x_optimize
= 1;
679 opts
->x_optimize_size
= 0;
680 opts
->x_optimize_fast
= 0;
681 opts
->x_optimize_debug
= 0;
685 const int optimize_val
= integral_argument (opt
->arg
);
686 if (optimize_val
== -1)
687 error_at (loc
, "argument to %<-O%> should be a non-negative "
688 "integer, %<g%>, %<s%> or %<fast%>");
691 opts
->x_optimize
= optimize_val
;
692 if ((unsigned int) opts
->x_optimize
> 255)
693 opts
->x_optimize
= 255;
694 opts
->x_optimize_size
= 0;
695 opts
->x_optimize_fast
= 0;
696 opts
->x_optimize_debug
= 0;
702 opts
->x_optimize_size
= 1;
704 /* Optimizing for size forces optimize to be 2. */
705 opts
->x_optimize
= 2;
706 opts
->x_optimize_fast
= 0;
707 opts
->x_optimize_debug
= 0;
711 /* -Ofast only adds flags to -O3. */
712 opts
->x_optimize_size
= 0;
713 opts
->x_optimize
= 3;
714 opts
->x_optimize_fast
= 1;
715 opts
->x_optimize_debug
= 0;
719 /* -Og selects optimization level 1. */
720 opts
->x_optimize_size
= 0;
721 opts
->x_optimize
= 1;
722 opts
->x_optimize_fast
= 0;
723 opts
->x_optimize_debug
= 1;
732 /* Ignore other options in this prescan. */
737 maybe_default_options (opts
, opts_set
, default_options_table
,
738 opts
->x_optimize
, opts
->x_optimize_size
,
739 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
740 lang_mask
, handlers
, loc
, dc
);
742 /* -O2 param settings. */
743 opt2
= (opts
->x_optimize
>= 2);
746 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_pta
, true);
748 /* Track fields in field-sensitive alias analysis. */
750 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_fields_for_field_sensitive
,
753 if (opts
->x_optimize_size
)
754 /* We want to crossjump as much as possible. */
755 SET_OPTION_IF_UNSET (opts
, opts_set
, param_min_crossjump_insns
, 1);
757 /* Restrict the amount of work combine does at -Og while retaining
758 most of its useful transforms. */
759 if (opts
->x_optimize_debug
)
760 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_combine_insns
, 2);
762 /* Allow default optimizations to be specified on a per-machine basis. */
763 maybe_default_options (opts
, opts_set
,
764 targetm_common
.option_optimization_table
,
765 opts
->x_optimize
, opts
->x_optimize_size
,
766 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
767 lang_mask
, handlers
, loc
, dc
);
770 /* Control IPA optimizations based on different live patching LEVEL. */
772 control_options_for_live_patching (struct gcc_options
*opts
,
773 struct gcc_options
*opts_set
,
774 enum live_patching_level level
,
777 gcc_assert (level
> LIVE_PATCHING_NONE
);
781 case LIVE_PATCHING_INLINE_ONLY_STATIC
:
782 if (opts_set
->x_flag_ipa_cp_clone
&& opts
->x_flag_ipa_cp_clone
)
783 error_at (loc
, "%qs is incompatible with %qs",
784 "-fipa-cp-clone", "-flive-patching=inline-only-static");
786 opts
->x_flag_ipa_cp_clone
= 0;
788 if (opts_set
->x_flag_ipa_sra
&& opts
->x_flag_ipa_sra
)
789 error_at (loc
, "%qs is incompatible with %qs",
790 "-fipa-sra", "-flive-patching=inline-only-static");
792 opts
->x_flag_ipa_sra
= 0;
794 if (opts_set
->x_flag_partial_inlining
&& opts
->x_flag_partial_inlining
)
795 error_at (loc
, "%qs is incompatible with %qs",
796 "-fpartial-inlining", "-flive-patching=inline-only-static");
798 opts
->x_flag_partial_inlining
= 0;
800 if (opts_set
->x_flag_ipa_cp
&& opts
->x_flag_ipa_cp
)
801 error_at (loc
, "%qs is incompatible with %qs",
802 "-fipa-cp", "-flive-patching=inline-only-static");
804 opts
->x_flag_ipa_cp
= 0;
807 case LIVE_PATCHING_INLINE_CLONE
:
808 /* live patching should disable whole-program optimization. */
809 if (opts_set
->x_flag_whole_program
&& opts
->x_flag_whole_program
)
810 error_at (loc
, "%qs is incompatible with %qs",
812 "-flive-patching=inline-only-static|inline-clone");
814 opts
->x_flag_whole_program
= 0;
816 /* visibility change should be excluded by !flag_whole_program
817 && !in_lto_p && !flag_ipa_cp_clone && !flag_ipa_sra
818 && !flag_partial_inlining. */
820 if (opts_set
->x_flag_ipa_pta
&& opts
->x_flag_ipa_pta
)
821 error_at (loc
, "%qs is incompatible with %qs",
823 "-flive-patching=inline-only-static|inline-clone");
825 opts
->x_flag_ipa_pta
= 0;
827 if (opts_set
->x_flag_ipa_reference
&& opts
->x_flag_ipa_reference
)
828 error_at (loc
, "%qs is incompatible with %qs",
830 "-flive-patching=inline-only-static|inline-clone");
832 opts
->x_flag_ipa_reference
= 0;
834 if (opts_set
->x_flag_ipa_ra
&& opts
->x_flag_ipa_ra
)
835 error_at (loc
, "%qs is incompatible with %qs",
837 "-flive-patching=inline-only-static|inline-clone");
839 opts
->x_flag_ipa_ra
= 0;
841 if (opts_set
->x_flag_ipa_icf
&& opts
->x_flag_ipa_icf
)
842 error_at (loc
, "%qs is incompatible with %qs",
844 "-flive-patching=inline-only-static|inline-clone");
846 opts
->x_flag_ipa_icf
= 0;
848 if (opts_set
->x_flag_ipa_icf_functions
&& opts
->x_flag_ipa_icf_functions
)
849 error_at (loc
, "%qs is incompatible with %qs",
850 "-fipa-icf-functions",
851 "-flive-patching=inline-only-static|inline-clone");
853 opts
->x_flag_ipa_icf_functions
= 0;
855 if (opts_set
->x_flag_ipa_icf_variables
&& opts
->x_flag_ipa_icf_variables
)
856 error_at (loc
, "%qs is incompatible with %qs",
857 "-fipa-icf-variables",
858 "-flive-patching=inline-only-static|inline-clone");
860 opts
->x_flag_ipa_icf_variables
= 0;
862 if (opts_set
->x_flag_ipa_bit_cp
&& opts
->x_flag_ipa_bit_cp
)
863 error_at (loc
, "%qs is incompatible with %qs",
865 "-flive-patching=inline-only-static|inline-clone");
867 opts
->x_flag_ipa_bit_cp
= 0;
869 if (opts_set
->x_flag_ipa_vrp
&& opts
->x_flag_ipa_vrp
)
870 error_at (loc
, "%qs is incompatible with %qs",
872 "-flive-patching=inline-only-static|inline-clone");
874 opts
->x_flag_ipa_vrp
= 0;
876 if (opts_set
->x_flag_ipa_pure_const
&& opts
->x_flag_ipa_pure_const
)
877 error_at (loc
, "%qs is incompatible with %qs",
879 "-flive-patching=inline-only-static|inline-clone");
881 opts
->x_flag_ipa_pure_const
= 0;
883 if (opts_set
->x_flag_ipa_modref
&& opts
->x_flag_ipa_modref
)
885 "%<-fipa-modref%> is incompatible with "
886 "%<-flive-patching=inline-only-static|inline-clone%>");
888 opts
->x_flag_ipa_modref
= 0;
890 /* FIXME: disable unreachable code removal. */
892 /* discovery of functions/variables with no address taken. */
893 if (opts_set
->x_flag_ipa_reference_addressable
894 && opts
->x_flag_ipa_reference_addressable
)
895 error_at (loc
, "%qs is incompatible with %qs",
896 "-fipa-reference-addressable",
897 "-flive-patching=inline-only-static|inline-clone");
899 opts
->x_flag_ipa_reference_addressable
= 0;
901 /* ipa stack alignment propagation. */
902 if (opts_set
->x_flag_ipa_stack_alignment
903 && opts
->x_flag_ipa_stack_alignment
)
904 error_at (loc
, "%qs is incompatible with %qs",
905 "-fipa-stack-alignment",
906 "-flive-patching=inline-only-static|inline-clone");
908 opts
->x_flag_ipa_stack_alignment
= 0;
915 /* --help option argument if set. */
916 vec
<const char *> help_option_arguments
;
918 /* Return the string name describing a sanitizer argument which has been
919 provided on the command line and has set this particular flag. */
921 find_sanitizer_argument (struct gcc_options
*opts
, unsigned int flags
)
923 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
925 /* Need to find the sanitizer_opts element which:
926 a) Could have set the flags requested.
927 b) Has been set on the command line.
929 Can have (a) without (b) if the flag requested is e.g.
930 SANITIZE_ADDRESS, since both -fsanitize=address and
931 -fsanitize=kernel-address set this flag.
933 Can have (b) without (a) by requesting more than one sanitizer on the
935 if ((sanitizer_opts
[i
].flag
& opts
->x_flag_sanitize
)
936 != sanitizer_opts
[i
].flag
)
938 if ((sanitizer_opts
[i
].flag
& flags
) != flags
)
940 return sanitizer_opts
[i
].name
;
946 /* Report an error to the user about sanitizer options they have requested
947 which have set conflicting flags.
949 LEFT and RIGHT indicate sanitizer flags which conflict with each other, this
950 function reports an error if both have been set in OPTS->x_flag_sanitize and
951 ensures the error identifies the requested command line options that have
954 report_conflicting_sanitizer_options (struct gcc_options
*opts
, location_t loc
,
955 unsigned int left
, unsigned int right
)
957 unsigned int left_seen
= (opts
->x_flag_sanitize
& left
);
958 unsigned int right_seen
= (opts
->x_flag_sanitize
& right
);
959 if (left_seen
&& right_seen
)
961 const char* left_arg
= find_sanitizer_argument (opts
, left_seen
);
962 const char* right_arg
= find_sanitizer_argument (opts
, right_seen
);
963 gcc_assert (left_arg
&& right_arg
);
965 "%<-fsanitize=%s%> is incompatible with %<-fsanitize=%s%>",
966 left_arg
, right_arg
);
970 /* After all options at LOC have been read into OPTS and OPTS_SET,
971 finalize settings of those options and diagnose incompatible
974 finish_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
977 enum unwind_info_type ui_except
;
979 if (opts
->x_dump_base_name
980 && ! opts
->x_dump_base_name_prefixed
)
982 const char *sep
= opts
->x_dump_base_name
;
985 if (IS_DIR_SEPARATOR (*sep
))
989 /* If dump_base_path contains subdirectories, don't prepend
991 else if (opts
->x_dump_dir_name
)
992 /* We have a DUMP_DIR_NAME, prepend that. */
993 opts
->x_dump_base_name
= opts_concat (opts
->x_dump_dir_name
,
994 opts
->x_dump_base_name
, NULL
);
996 /* It is definitely prefixed now. */
997 opts
->x_dump_base_name_prefixed
= true;
1000 /* Handle related options for unit-at-a-time, toplevel-reorder, and
1002 if (!opts
->x_flag_unit_at_a_time
)
1004 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
1005 error_at (loc
, "section anchors must be disabled when unit-at-a-time "
1007 opts
->x_flag_section_anchors
= 0;
1008 if (opts
->x_flag_toplevel_reorder
== 1)
1009 error_at (loc
, "toplevel reorder must be disabled when unit-at-a-time "
1011 opts
->x_flag_toplevel_reorder
= 0;
1014 /* -fself-test depends on the state of the compiler prior to
1015 compiling anything. Ideally it should be run on an empty source
1016 file. However, in case we get run with actual source, assume
1017 -fsyntax-only which will inhibit any compiler initialization
1018 which may confuse the self tests. */
1019 if (opts
->x_flag_self_test
)
1020 opts
->x_flag_syntax_only
= 1;
1022 if (opts
->x_flag_tm
&& opts
->x_flag_non_call_exceptions
)
1023 sorry ("transactional memory is not supported with non-call exceptions");
1025 /* Unless the user has asked for section anchors, we disable toplevel
1026 reordering at -O0 to disable transformations that might be surprising
1027 to end users and to get -fno-toplevel-reorder tested. */
1028 if (!opts
->x_optimize
1029 && opts
->x_flag_toplevel_reorder
== 2
1030 && !(opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
))
1032 opts
->x_flag_toplevel_reorder
= 0;
1033 opts
->x_flag_section_anchors
= 0;
1035 if (!opts
->x_flag_toplevel_reorder
)
1037 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
1038 error_at (loc
, "section anchors must be disabled when toplevel reorder"
1040 opts
->x_flag_section_anchors
= 0;
1043 if (!opts
->x_flag_opts_finished
)
1045 /* We initialize opts->x_flag_pie to -1 so that targets can set a
1047 if (opts
->x_flag_pie
== -1)
1049 /* We initialize opts->x_flag_pic to -1 so that we can tell if
1050 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
1051 if (opts
->x_flag_pic
== -1)
1052 opts
->x_flag_pie
= DEFAULT_FLAG_PIE
;
1054 opts
->x_flag_pie
= 0;
1056 /* If -fPIE or -fpie is used, turn on PIC. */
1057 if (opts
->x_flag_pie
)
1058 opts
->x_flag_pic
= opts
->x_flag_pie
;
1059 else if (opts
->x_flag_pic
== -1)
1060 opts
->x_flag_pic
= 0;
1061 if (opts
->x_flag_pic
&& !opts
->x_flag_pie
)
1062 opts
->x_flag_shlib
= 1;
1063 opts
->x_flag_opts_finished
= true;
1066 /* We initialize opts->x_flag_stack_protect to -1 so that targets
1067 can set a default value. */
1068 if (opts
->x_flag_stack_protect
== -1)
1069 opts
->x_flag_stack_protect
= DEFAULT_FLAG_SSP
;
1071 if (opts
->x_optimize
== 0)
1073 /* Inlining does not work if not optimizing,
1074 so force it not to be done. */
1075 opts
->x_warn_inline
= 0;
1076 opts
->x_flag_no_inline
= 1;
1079 /* The optimization to partition hot and cold basic blocks into separate
1080 sections of the .o and executable files does not work (currently)
1081 with exception handling. This is because there is no support for
1082 generating unwind info. If opts->x_flag_exceptions is turned on
1083 we need to turn off the partitioning optimization. */
1085 ui_except
= targetm_common
.except_unwind_info (opts
);
1087 if (opts
->x_flag_exceptions
1088 && opts
->x_flag_reorder_blocks_and_partition
1089 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1091 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1093 "%<-freorder-blocks-and-partition%> does not work "
1094 "with exceptions on this architecture");
1095 opts
->x_flag_reorder_blocks_and_partition
= 0;
1096 opts
->x_flag_reorder_blocks
= 1;
1099 /* If user requested unwind info, then turn off the partitioning
1102 if (opts
->x_flag_unwind_tables
1103 && !targetm_common
.unwind_tables_default
1104 && opts
->x_flag_reorder_blocks_and_partition
1105 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1107 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1109 "%<-freorder-blocks-and-partition%> does not support "
1110 "unwind info on this architecture");
1111 opts
->x_flag_reorder_blocks_and_partition
= 0;
1112 opts
->x_flag_reorder_blocks
= 1;
1115 /* If the target requested unwind info, then turn off the partitioning
1116 optimization with a different message. Likewise, if the target does not
1117 support named sections. */
1119 if (opts
->x_flag_reorder_blocks_and_partition
1120 && (!targetm_common
.have_named_sections
1121 || (opts
->x_flag_unwind_tables
1122 && targetm_common
.unwind_tables_default
1123 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
1125 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1127 "%<-freorder-blocks-and-partition%> does not work "
1128 "on this architecture");
1129 opts
->x_flag_reorder_blocks_and_partition
= 0;
1130 opts
->x_flag_reorder_blocks
= 1;
1134 /* Pipelining of outer loops is only possible when general pipelining
1135 capabilities are requested. */
1136 if (!opts
->x_flag_sel_sched_pipelining
)
1137 opts
->x_flag_sel_sched_pipelining_outer_loops
= 0;
1139 if (opts
->x_flag_conserve_stack
)
1141 SET_OPTION_IF_UNSET (opts
, opts_set
, param_large_stack_frame
, 100);
1142 SET_OPTION_IF_UNSET (opts
, opts_set
, param_stack_frame_growth
, 40);
1145 if (opts
->x_flag_lto
)
1148 opts
->x_flag_generate_lto
= 1;
1150 /* When generating IL, do not operate in whole-program mode.
1151 Otherwise, symbols will be privatized too early, causing link
1153 opts
->x_flag_whole_program
= 0;
1155 error_at (loc
, "LTO support has not been enabled in this configuration");
1157 if (!opts
->x_flag_fat_lto_objects
1158 && (!HAVE_LTO_PLUGIN
1159 || (opts_set
->x_flag_use_linker_plugin
1160 && !opts
->x_flag_use_linker_plugin
)))
1162 if (opts_set
->x_flag_fat_lto_objects
)
1163 error_at (loc
, "%<-fno-fat-lto-objects%> are supported only with "
1165 opts
->x_flag_fat_lto_objects
= 1;
1168 /* -gsplit-dwarf isn't compatible with LTO, see PR88389. */
1169 if (opts
->x_dwarf_split_debug_info
)
1171 inform (loc
, "%<-gsplit-dwarf%> is not supported with LTO,"
1173 opts
->x_dwarf_split_debug_info
= 0;
1177 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
1178 default value if they choose based on other options. */
1179 if (opts
->x_flag_split_stack
== -1)
1180 opts
->x_flag_split_stack
= 0;
1181 else if (opts
->x_flag_split_stack
)
1183 if (!targetm_common
.supports_split_stack (true, opts
))
1185 error_at (loc
, "%<-fsplit-stack%> is not supported by "
1186 "this compiler configuration");
1187 opts
->x_flag_split_stack
= 0;
1191 /* If stack splitting is turned on, and the user did not explicitly
1192 request function partitioning, turn off partitioning, as it
1193 confuses the linker when trying to handle partitioned split-stack
1194 code that calls a non-split-stack functions. But if partitioning
1195 was turned on explicitly just hope for the best. */
1196 if (opts
->x_flag_split_stack
1197 && opts
->x_flag_reorder_blocks_and_partition
)
1198 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_reorder_blocks_and_partition
, 0);
1200 if (opts
->x_flag_reorder_blocks_and_partition
)
1201 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_reorder_functions
, 1);
1203 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
1204 if (opts
->x_dwarf_split_debug_info
)
1205 opts
->x_debug_generate_pub_sections
= 2;
1207 if ((opts
->x_flag_sanitize
1208 & (SANITIZE_USER_ADDRESS
| SANITIZE_KERNEL_ADDRESS
)) == 0)
1210 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_COMPARE
)
1212 "%<-fsanitize=pointer-compare%> must be combined with "
1213 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1214 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_SUBTRACT
)
1216 "%<-fsanitize=pointer-subtract%> must be combined with "
1217 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1220 /* Address sanitizers conflict with the thread sanitizer. */
1221 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_THREAD
,
1222 SANITIZE_ADDRESS
| SANITIZE_HWADDRESS
);
1223 /* The leak sanitizer conflicts with the thread sanitizer. */
1224 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_LEAK
,
1227 /* No combination of HWASAN and ASAN work together. */
1228 report_conflicting_sanitizer_options (opts
, loc
,
1229 SANITIZE_HWADDRESS
, SANITIZE_ADDRESS
);
1231 /* The userspace and kernel address sanitizers conflict with each other. */
1232 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_USER_HWADDRESS
,
1233 SANITIZE_KERNEL_HWADDRESS
);
1234 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_USER_ADDRESS
,
1235 SANITIZE_KERNEL_ADDRESS
);
1237 /* Check error recovery for -fsanitize-recover option. */
1238 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1239 if ((opts
->x_flag_sanitize_recover
& sanitizer_opts
[i
].flag
)
1240 && !sanitizer_opts
[i
].can_recover
)
1241 error_at (loc
, "%<-fsanitize-recover=%s%> is not supported",
1242 sanitizer_opts
[i
].name
);
1244 /* When instrumenting the pointers, we don't want to remove
1245 the null pointer checks. */
1246 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
1247 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
1248 opts
->x_flag_delete_null_pointer_checks
= 0;
1250 /* Aggressive compiler optimizations may cause false negatives. */
1251 if (opts
->x_flag_sanitize
& ~(SANITIZE_LEAK
| SANITIZE_UNREACHABLE
))
1252 opts
->x_flag_aggressive_loop_optimizations
= 0;
1254 /* Enable -fsanitize-address-use-after-scope if either address sanitizer is
1256 if (opts
->x_flag_sanitize
1257 & (SANITIZE_USER_ADDRESS
| SANITIZE_USER_HWADDRESS
))
1258 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_sanitize_address_use_after_scope
,
1261 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1263 if (opts
->x_flag_sanitize_address_use_after_scope
)
1265 if (opts
->x_flag_stack_reuse
!= SR_NONE
1266 && opts_set
->x_flag_stack_reuse
!= SR_NONE
)
1268 "%<-fsanitize-address-use-after-scope%> requires "
1269 "%<-fstack-reuse=none%> option");
1271 opts
->x_flag_stack_reuse
= SR_NONE
;
1274 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
) && opts
->x_flag_tm
)
1275 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1277 if ((opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) && opts
->x_flag_tm
)
1278 sorry ("transactional memory is not supported with "
1279 "%<-fsanitize=kernel-address%>");
1281 /* Currently live patching is not support for LTO. */
1282 if (opts
->x_flag_live_patching
&& opts
->x_flag_lto
)
1283 sorry ("live patching is not supported with LTO");
1285 /* Currently vtable verification is not supported for LTO */
1286 if (opts
->x_flag_vtable_verify
&& opts
->x_flag_lto
)
1287 sorry ("vtable verification is not supported with LTO");
1289 /* Control IPA optimizations based on different -flive-patching level. */
1290 if (opts
->x_flag_live_patching
)
1291 control_options_for_live_patching (opts
, opts_set
,
1292 opts
->x_flag_live_patching
,
1295 /* Unrolling all loops implies that standard loop unrolling must also
1297 if (opts
->x_flag_unroll_all_loops
)
1298 opts
->x_flag_unroll_loops
= 1;
1300 /* Allow cunroll to grow size accordingly. */
1301 if (!opts_set
->x_flag_cunroll_grow_size
)
1302 opts
->x_flag_cunroll_grow_size
1303 = (opts
->x_flag_unroll_loops
1304 || opts
->x_flag_peel_loops
1305 || opts
->x_optimize
>= 3);
1308 #define LEFT_COLUMN 27
1310 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1311 followed by word-wrapped HELP in a second column. */
1313 wrap_help (const char *help
,
1315 unsigned int item_width
,
1316 unsigned int columns
)
1318 unsigned int col_width
= LEFT_COLUMN
;
1319 unsigned int remaining
, room
, len
;
1321 remaining
= strlen (help
);
1325 room
= columns
- 3 - MAX (col_width
, item_width
);
1334 for (i
= 0; help
[i
]; i
++)
1336 if (i
>= room
&& len
!= remaining
)
1340 else if ((help
[i
] == '-' || help
[i
] == '/')
1341 && help
[i
+ 1] != ' '
1342 && i
> 0 && ISALPHA (help
[i
- 1]))
1347 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1349 while (help
[len
] == ' ')
1357 /* Data structure used to print list of valid option values. */
1359 class option_help_tuple
1362 option_help_tuple (int code
, vec
<const char *> values
):
1363 m_code (code
), m_values (values
)
1366 /* Code of an option. */
1369 /* List of possible values. */
1370 vec
<const char *> m_values
;
1373 /* Print help for a specific front-end, etc. */
1375 print_filtered_help (unsigned int include_flags
,
1376 unsigned int exclude_flags
,
1377 unsigned int any_flags
,
1378 unsigned int columns
,
1379 struct gcc_options
*opts
,
1380 unsigned int lang_mask
)
1385 bool displayed
= false;
1388 if (!opts
->x_help_printed
)
1389 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1391 if (!opts
->x_help_enum_printed
)
1392 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1394 auto_vec
<option_help_tuple
> help_tuples
;
1396 for (i
= 0; i
< cl_options_count
; i
++)
1398 const struct cl_option
*option
= cl_options
+ i
;
1403 if (include_flags
== 0
1404 || ((option
->flags
& include_flags
) != include_flags
))
1406 if ((option
->flags
& any_flags
) == 0)
1410 /* Skip unwanted switches. */
1411 if ((option
->flags
& exclude_flags
) != 0)
1414 /* The driver currently prints its own help text. */
1415 if ((option
->flags
& CL_DRIVER
) != 0
1416 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1417 | CL_COMMON
| CL_TARGET
)) == 0)
1420 /* If an option contains a language specification,
1421 exclude it from common unless all languages are present. */
1422 if ((include_flags
& CL_COMMON
)
1423 && !(option
->flags
& CL_DRIVER
)
1424 && (option
->flags
& CL_LANG_ALL
)
1425 && (option
->flags
& CL_LANG_ALL
) != CL_LANG_ALL
)
1429 /* Skip switches that have already been printed. */
1430 if (opts
->x_help_printed
[i
])
1433 opts
->x_help_printed
[i
] = true;
1435 help
= option
->help
;
1438 if (exclude_flags
& CL_UNDOCUMENTED
)
1441 help
= undocumented_msg
;
1444 /* Get the translation. */
1447 if (option
->alias_target
< N_OPTS
1448 && cl_options
[option
->alias_target
].help
)
1450 const struct cl_option
*target
= cl_options
+ option
->alias_target
;
1451 if (option
->help
== NULL
)
1453 /* The option is undocumented but is an alias for an option that
1454 is documented. If the option has alias arguments, then its
1455 purpose is to provide certain arguments to the other option, so
1456 inform the reader of this. Otherwise, point the reader to the
1457 other option in preference to the former. */
1459 if (option
->alias_arg
)
1461 if (option
->neg_alias_arg
)
1462 snprintf (new_help
, sizeof new_help
,
1463 _("Same as %s%s (or, in negated form, %s%s)."),
1464 target
->opt_text
, option
->alias_arg
,
1465 target
->opt_text
, option
->neg_alias_arg
);
1467 snprintf (new_help
, sizeof new_help
,
1469 target
->opt_text
, option
->alias_arg
);
1472 snprintf (new_help
, sizeof new_help
,
1478 /* For documented options with aliases, mention the aliased
1479 option's name for reference. */
1480 snprintf (new_help
, sizeof new_help
,
1481 _("%s Same as %s."),
1482 help
, cl_options
[option
->alias_target
].opt_text
);
1488 if (option
->warn_message
)
1490 /* Mention that the use of the option will trigger a warning. */
1491 if (help
== new_help
)
1492 snprintf (new_help
+ strlen (new_help
),
1493 sizeof new_help
- strlen (new_help
),
1494 " %s", _(use_diagnosed_msg
));
1496 snprintf (new_help
, sizeof new_help
,
1497 "%s %s", help
, _(use_diagnosed_msg
));
1502 /* Find the gap between the name of the
1503 option and its descriptive text. */
1504 tab
= strchr (help
, '\t');
1513 opt
= option
->opt_text
;
1517 /* With the -Q option enabled we change the descriptive text associated
1518 with an option to be an indication of its current setting. */
1519 if (!opts
->x_quiet_flag
)
1521 void *flag_var
= option_flag_var (i
, opts
);
1523 if (len
< (LEFT_COLUMN
+ 2))
1524 strcpy (new_help
, "\t\t");
1526 strcpy (new_help
, "\t");
1528 /* Set to print whether the option is enabled or disabled,
1529 or, if it's an alias for another option, the name of
1530 the aliased option. */
1531 bool print_state
= false;
1533 if (flag_var
!= NULL
1534 && option
->var_type
!= CLVC_DEFER
)
1536 /* If OPTION is only available for a specific subset
1537 of languages other than this one, mention them. */
1538 bool avail_for_lang
= true;
1539 if (unsigned langset
= option
->flags
& CL_LANG_ALL
)
1541 if (!(langset
& lang_mask
))
1543 avail_for_lang
= false;
1544 strcat (new_help
, _("[available in "));
1545 for (unsigned i
= 0, n
= 0; (1U << i
) < CL_LANG_ALL
; ++i
)
1546 if (langset
& (1U << i
))
1549 strcat (new_help
, ", ");
1550 strcat (new_help
, lang_names
[i
]);
1552 strcat (new_help
, "]");
1555 if (!avail_for_lang
)
1556 ; /* Print nothing else if the option is not available
1557 in the current language. */
1558 else if (option
->flags
& CL_JOINED
)
1560 if (option
->var_type
== CLVC_STRING
)
1562 if (* (const char **) flag_var
!= NULL
)
1563 snprintf (new_help
+ strlen (new_help
),
1564 sizeof (new_help
) - strlen (new_help
),
1565 "%s", * (const char **) flag_var
);
1567 else if (option
->var_type
== CLVC_ENUM
)
1569 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1571 const char *arg
= NULL
;
1573 value
= e
->get (flag_var
);
1574 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1576 arg
= _("[default]");
1577 snprintf (new_help
+ strlen (new_help
),
1578 sizeof (new_help
) - strlen (new_help
),
1583 if (option
->cl_host_wide_int
)
1584 sprintf (new_help
+ strlen (new_help
),
1585 _("%llu bytes"), (unsigned long long)
1586 *(unsigned HOST_WIDE_INT
*) flag_var
);
1588 sprintf (new_help
+ strlen (new_help
),
1589 "%i", * (int *) flag_var
);
1596 /* When there is no argument, print the option state only
1597 if the option takes no argument. */
1598 print_state
= !(option
->flags
& CL_JOINED
);
1602 if (option
->alias_target
< N_OPTS
1603 && option
->alias_target
!= OPT_SPECIAL_warn_removed
1604 && option
->alias_target
!= OPT_SPECIAL_ignore
1605 && option
->alias_target
!= OPT_SPECIAL_input_file
1606 && option
->alias_target
!= OPT_SPECIAL_program_name
1607 && option
->alias_target
!= OPT_SPECIAL_unknown
)
1609 const struct cl_option
*target
1610 = &cl_options
[option
->alias_target
];
1611 sprintf (new_help
+ strlen (new_help
), "%s%s",
1613 option
->alias_arg
? option
->alias_arg
: "");
1615 else if (option
->alias_target
== OPT_SPECIAL_ignore
)
1616 strcat (new_help
, ("[ignored]"));
1619 /* Print the state for an on/off option. */
1620 int ena
= option_enabled (i
, lang_mask
, opts
);
1622 strcat (new_help
, _("[enabled]"));
1624 strcat (new_help
, _("[disabled]"));
1631 if (option
->range_max
!= -1)
1634 snprintf (b
, sizeof (b
), "<%d,%d>", option
->range_min
,
1636 opt
= concat (opt
, b
, NULL
);
1640 wrap_help (help
, opt
, len
, columns
);
1643 if (option
->var_type
== CLVC_ENUM
1644 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1645 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1648 vec
<const char *> option_values
1649 = targetm_common
.get_valid_option_values (i
, NULL
);
1650 if (!option_values
.is_empty ())
1651 help_tuples
.safe_push (option_help_tuple (i
, option_values
));
1657 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1660 printf (_(" No options with the desired characteristics were found\n"));
1665 /* PR 31349: Tell the user how to see all of the
1666 options supported by a specific front end. */
1667 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1668 if ((1U << i
) & langs
)
1669 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1670 lang_names
[i
], lang_names
[i
]);
1674 else if (! displayed
)
1675 printf (_(" All options with the desired characteristics have already been displayed\n"));
1679 /* Print details of enumerated option arguments, if those
1680 enumerations have help text headings provided. If no help text
1681 is provided, presume that the possible values are listed in the
1682 help text for the relevant options. */
1683 for (i
= 0; i
< cl_enums_count
; i
++)
1685 unsigned int j
, pos
;
1687 if (opts
->x_help_enum_printed
[i
] != 1)
1689 if (cl_enums
[i
].help
== NULL
)
1691 printf (" %s\n ", _(cl_enums
[i
].help
));
1693 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1695 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1697 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1699 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1709 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1714 opts
->x_help_enum_printed
[i
] = 2;
1717 for (unsigned i
= 0; i
< help_tuples
.length (); i
++)
1719 const struct cl_option
*option
= cl_options
+ help_tuples
[i
].m_code
;
1720 printf (_(" Known valid arguments for %s option:\n "),
1722 for (unsigned j
= 0; j
< help_tuples
[i
].m_values
.length (); j
++)
1723 printf (" %s", help_tuples
[i
].m_values
[j
]);
1728 /* Display help for a specified type of option.
1729 The options must have ALL of the INCLUDE_FLAGS set
1730 ANY of the flags in the ANY_FLAGS set
1731 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1732 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1734 print_specific_help (unsigned int include_flags
,
1735 unsigned int exclude_flags
,
1736 unsigned int any_flags
,
1737 struct gcc_options
*opts
,
1738 unsigned int lang_mask
)
1740 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1741 const char * description
= NULL
;
1742 const char * descrip_extra
= "";
1746 /* Sanity check: Make sure that we do not have more
1747 languages than we have bits available to enumerate them. */
1748 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1750 /* If we have not done so already, obtain
1751 the desired maximum width of the output. */
1752 if (opts
->x_help_columns
== 0)
1754 opts
->x_help_columns
= get_terminal_width ();
1755 if (opts
->x_help_columns
== INT_MAX
)
1756 /* Use a reasonable default. */
1757 opts
->x_help_columns
= 80;
1760 /* Decide upon the title for the options that we are going to display. */
1761 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1763 switch (flag
& include_flags
)
1770 description
= _("The following options are target specific");
1773 description
= _("The following options control compiler warning messages");
1775 case CL_OPTIMIZATION
:
1776 description
= _("The following options control optimizations");
1779 description
= _("The following options are language-independent");
1782 description
= _("The following options control parameters");
1785 if (i
>= cl_lang_count
)
1787 if (exclude_flags
& all_langs_mask
)
1788 description
= _("The following options are specific to just the language ");
1790 description
= _("The following options are supported by the language ");
1791 descrip_extra
= lang_names
[i
];
1796 if (description
== NULL
)
1800 if (include_flags
& CL_UNDOCUMENTED
)
1801 description
= _("The following options are not documented");
1802 else if (include_flags
& CL_SEPARATE
)
1803 description
= _("The following options take separate arguments");
1804 else if (include_flags
& CL_JOINED
)
1805 description
= _("The following options take joined arguments");
1808 internal_error ("unrecognized %<include_flags 0x%x%> passed "
1809 "to %<print_specific_help%>",
1816 if (any_flags
& all_langs_mask
)
1817 description
= _("The following options are language-related");
1819 description
= _("The following options are language-independent");
1823 printf ("%s%s:\n", description
, descrip_extra
);
1824 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
1825 opts
->x_help_columns
, opts
, lang_mask
);
1828 /* Enable FDO-related flags. */
1831 enable_fdo_optimizations (struct gcc_options
*opts
,
1832 struct gcc_options
*opts_set
,
1835 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_branch_probabilities
, value
);
1836 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
1837 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_loops
, value
);
1838 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_peel_loops
, value
);
1839 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tracer
, value
);
1840 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_value_profile_transformations
,
1842 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
1843 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp
, value
);
1846 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp_clone
, 1);
1847 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, 1);
1849 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_predictive_commoning
, value
);
1850 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_split_loops
, value
);
1851 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unswitch_loops
, value
);
1852 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_gcse_after_reload
, value
);
1853 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_vectorize
, value
);
1854 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_slp_vectorize
, value
);
1855 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_version_loops_for_strides
, value
);
1856 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_vect_cost_model
,
1857 VECT_COST_MODEL_DYNAMIC
);
1858 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribute_patterns
,
1860 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_loop_interchange
, value
);
1861 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_jam
, value
);
1862 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribution
, value
);
1865 /* -f{,no-}sanitize{,-recover}= suboptions. */
1866 const struct sanitizer_opts_s sanitizer_opts
[] =
1868 #define SANITIZER_OPT(name, flags, recover) \
1869 { #name, flags, sizeof #name - 1, recover }
1870 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true),
1871 SANITIZER_OPT (hwaddress
, (SANITIZE_HWADDRESS
| SANITIZE_USER_HWADDRESS
),
1873 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
1875 SANITIZER_OPT (kernel
-hwaddress
,
1876 (SANITIZE_HWADDRESS
| SANITIZE_KERNEL_HWADDRESS
),
1878 SANITIZER_OPT (pointer
-compare
, SANITIZE_POINTER_COMPARE
, true),
1879 SANITIZER_OPT (pointer
-subtract
, SANITIZE_POINTER_SUBTRACT
, true),
1880 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false),
1881 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false),
1882 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true),
1883 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true),
1884 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true),
1885 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true),
1886 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true),
1887 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false),
1888 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true),
1889 SANITIZER_OPT (return, SANITIZE_RETURN
, false),
1890 SANITIZER_OPT (null
, SANITIZE_NULL
, true),
1891 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true),
1892 SANITIZER_OPT (bool, SANITIZE_BOOL
, true),
1893 SANITIZER_OPT (enum, SANITIZE_ENUM
, true),
1894 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true),
1895 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true),
1896 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true),
1897 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true),
1898 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true),
1899 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true),
1900 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
1902 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true),
1903 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true),
1904 SANITIZER_OPT (pointer
-overflow
, SANITIZE_POINTER_OVERFLOW
, true),
1905 SANITIZER_OPT (builtin
, SANITIZE_BUILTIN
, true),
1906 SANITIZER_OPT (all
, ~0U, true),
1907 #undef SANITIZER_OPT
1908 { NULL
, 0U, 0UL, false }
1911 /* -f{,no-}sanitize-coverage= suboptions. */
1912 const struct sanitizer_opts_s coverage_sanitizer_opts
[] =
1914 #define COVERAGE_SANITIZER_OPT(name, flags) \
1915 { #name, flags, sizeof #name - 1, true }
1916 COVERAGE_SANITIZER_OPT (trace
-pc
, SANITIZE_COV_TRACE_PC
),
1917 COVERAGE_SANITIZER_OPT (trace
-cmp
, SANITIZE_COV_TRACE_CMP
),
1918 #undef COVERAGE_SANITIZER_OPT
1919 { NULL
, 0U, 0UL, false }
1922 /* -fzero-call-used-regs= suboptions. */
1923 const struct zero_call_used_regs_opts_s zero_call_used_regs_opts
[] =
1925 #define ZERO_CALL_USED_REGS_OPT(name, flags) \
1927 ZERO_CALL_USED_REGS_OPT (skip
, zero_regs_flags::SKIP
),
1928 ZERO_CALL_USED_REGS_OPT (used
-gpr
-arg
, zero_regs_flags::USED_GPR_ARG
),
1929 ZERO_CALL_USED_REGS_OPT (used
-gpr
, zero_regs_flags::USED_GPR
),
1930 ZERO_CALL_USED_REGS_OPT (used
-arg
, zero_regs_flags::USED_ARG
),
1931 ZERO_CALL_USED_REGS_OPT (used
, zero_regs_flags::USED
),
1932 ZERO_CALL_USED_REGS_OPT (all
-gpr
-arg
, zero_regs_flags::ALL_GPR_ARG
),
1933 ZERO_CALL_USED_REGS_OPT (all
-gpr
, zero_regs_flags::ALL_GPR
),
1934 ZERO_CALL_USED_REGS_OPT (all
-arg
, zero_regs_flags::ALL_ARG
),
1935 ZERO_CALL_USED_REGS_OPT (all
, zero_regs_flags::ALL
),
1936 #undef ZERO_CALL_USED_REGS_OPT
1940 /* A struct for describing a run of chars within a string. */
1942 class string_fragment
1945 string_fragment (const char *start
, size_t len
)
1946 : m_start (start
), m_len (len
) {}
1948 const char *m_start
;
1952 /* Specialization of edit_distance_traits for string_fragment,
1953 for use by get_closest_sanitizer_option. */
1956 struct edit_distance_traits
<const string_fragment
&>
1958 static size_t get_length (const string_fragment
&fragment
)
1960 return fragment
.m_len
;
1963 static const char *get_string (const string_fragment
&fragment
)
1965 return fragment
.m_start
;
1969 /* Given ARG, an unrecognized sanitizer option, return the best
1970 matching sanitizer option, or NULL if there isn't one.
1971 OPTS is array of candidate sanitizer options.
1972 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or
1973 OPT_fsanitize_coverage_.
1974 VALUE is non-zero for the regular form of the option, zero
1975 for the "no-" form (e.g. "-fno-sanitize-recover="). */
1978 get_closest_sanitizer_option (const string_fragment
&arg
,
1979 const struct sanitizer_opts_s
*opts
,
1980 enum opt_code code
, int value
)
1982 best_match
<const string_fragment
&, const char*> bm (arg
);
1983 for (int i
= 0; opts
[i
].name
!= NULL
; ++i
)
1985 /* -fsanitize=all is not valid, so don't offer it. */
1986 if (code
== OPT_fsanitize_
1987 && opts
[i
].flag
== ~0U
1991 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
1992 don't offer the non-recoverable options. */
1993 if (code
== OPT_fsanitize_recover_
1994 && !opts
[i
].can_recover
1998 bm
.consider (opts
[i
].name
);
2000 return bm
.get_best_meaningful_candidate ();
2003 /* Parse comma separated sanitizer suboptions from P for option SCODE,
2004 adjust previous FLAGS and return new ones. If COMPLAIN is false,
2005 don't issue diagnostics. */
2008 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
2009 unsigned int flags
, int value
, bool complain
)
2011 enum opt_code code
= (enum opt_code
) scode
;
2013 const struct sanitizer_opts_s
*opts
;
2014 if (code
== OPT_fsanitize_coverage_
)
2015 opts
= coverage_sanitizer_opts
;
2017 opts
= sanitizer_opts
;
2023 const char *comma
= strchr (p
, ',');
2035 /* Check to see if the string matches an option class name. */
2036 for (i
= 0; opts
[i
].name
!= NULL
; ++i
)
2037 if (len
== opts
[i
].len
&& memcmp (p
, opts
[i
].name
, len
) == 0)
2039 /* Handle both -fsanitize and -fno-sanitize cases. */
2040 if (value
&& opts
[i
].flag
== ~0U)
2042 if (code
== OPT_fsanitize_
)
2045 error_at (loc
, "%<-fsanitize=all%> option is not valid");
2048 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
2049 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2053 /* Do not enable -fsanitize-recover=unreachable and
2054 -fsanitize-recover=return if -fsanitize-recover=undefined
2056 if (code
== OPT_fsanitize_recover_
2057 && opts
[i
].flag
== SANITIZE_UNDEFINED
)
2058 flags
|= (SANITIZE_UNDEFINED
2059 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
2061 flags
|= opts
[i
].flag
;
2064 flags
&= ~opts
[i
].flag
;
2069 if (! found
&& complain
)
2072 = get_closest_sanitizer_option (string_fragment (p
, len
),
2076 if (code
== OPT_fsanitize_recover_
)
2077 suffix
= "-recover";
2078 else if (code
== OPT_fsanitize_coverage_
)
2079 suffix
= "-coverage";
2085 "unrecognized argument to %<-f%ssanitize%s=%> "
2086 "option: %q.*s; did you mean %qs?",
2088 suffix
, (int) len
, p
, hint
);
2091 "unrecognized argument to %<-f%ssanitize%s=%> option: "
2092 "%q.*s", value
? "" : "no-",
2093 suffix
, (int) len
, p
);
2103 /* Parse string values of no_sanitize attribute passed in VALUE.
2104 Values are separated with comma. */
2107 parse_no_sanitize_attribute (char *value
)
2109 unsigned int flags
= 0;
2111 char *q
= strtok (value
, ",");
2115 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
2116 if (strcmp (sanitizer_opts
[i
].name
, q
) == 0)
2118 flags
|= sanitizer_opts
[i
].flag
;
2119 if (sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
2120 flags
|= SANITIZE_UNDEFINED_NONDEFAULT
;
2124 if (sanitizer_opts
[i
].name
== NULL
)
2125 warning (OPT_Wattributes
,
2126 "%qs attribute directive ignored", q
);
2128 q
= strtok (NULL
, ",");
2134 /* Parse -fzero-call-used-regs suboptions from ARG, return the FLAGS. */
2137 parse_zero_call_used_regs_options (const char *arg
)
2139 unsigned int flags
= 0;
2141 /* Check to see if the string matches a sub-option name. */
2142 for (unsigned int i
= 0; zero_call_used_regs_opts
[i
].name
!= NULL
; ++i
)
2143 if (strcmp (arg
, zero_call_used_regs_opts
[i
].name
) == 0)
2145 flags
= zero_call_used_regs_opts
[i
].flag
;
2150 error ("unrecognized argument to %<-fzero-call-used-regs=%>: %qs", arg
);
2155 /* Parse -falign-NAME format for a FLAG value. Return individual
2156 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
2157 set, print error message at LOC location. */
2160 parse_and_check_align_values (const char *flag
,
2162 auto_vec
<unsigned> &result_values
,
2166 char *str
= xstrdup (flag
);
2167 for (char *p
= strtok (str
, ":"); p
; p
= strtok (NULL
, ":"))
2170 int v
= strtol (p
, &end
, 10);
2171 if (*end
!= '\0' || v
< 0)
2174 error_at (loc
, "invalid arguments for %<-falign-%s%> option: %qs",
2180 result_values
.safe_push ((unsigned)v
);
2185 /* Check that we have a correct number of values. */
2186 if (result_values
.is_empty () || result_values
.length () > 4)
2189 error_at (loc
, "invalid number of arguments for %<-falign-%s%> "
2190 "option: %qs", name
, flag
);
2194 for (unsigned i
= 0; i
< result_values
.length (); i
++)
2195 if (result_values
[i
] > MAX_CODE_ALIGN_VALUE
)
2198 error_at (loc
, "%<-falign-%s%> is not between 0 and %d",
2199 name
, MAX_CODE_ALIGN_VALUE
);
2206 /* Check that alignment value FLAG for -falign-NAME is valid at a given
2207 location LOC. OPT_STR points to the stored -falign-NAME=argument and
2208 OPT_FLAG points to the associated -falign-NAME on/off flag. */
2211 check_alignment_argument (location_t loc
, const char *flag
, const char *name
,
2212 int *opt_flag
, const char **opt_str
)
2214 auto_vec
<unsigned> align_result
;
2215 parse_and_check_align_values (flag
, name
, align_result
, true, loc
);
2217 if (align_result
.length() >= 1 && align_result
[0] == 0)
2224 /* Parse argument of -fpatchable-function-entry option ARG and store
2225 corresponding values to PATCH_AREA_SIZE and PATCH_AREA_START.
2226 If REPORT_ERROR is set to true, generate error for a problematic
2227 option arguments. */
2230 parse_and_check_patch_area (const char *arg
, bool report_error
,
2231 HOST_WIDE_INT
*patch_area_size
,
2232 HOST_WIDE_INT
*patch_area_start
)
2234 *patch_area_size
= 0;
2235 *patch_area_start
= 0;
2240 char *patch_area_arg
= xstrdup (arg
);
2241 char *comma
= strchr (patch_area_arg
, ',');
2245 *patch_area_size
= integral_argument (patch_area_arg
);
2246 *patch_area_start
= integral_argument (comma
+ 1);
2249 *patch_area_size
= integral_argument (patch_area_arg
);
2251 if (*patch_area_size
< 0
2252 || *patch_area_size
> USHRT_MAX
2253 || *patch_area_start
< 0
2254 || *patch_area_start
> USHRT_MAX
2255 || *patch_area_size
< *patch_area_start
)
2257 error ("invalid arguments for %<-fpatchable-function-entry%>");
2259 free (patch_area_arg
);
2262 /* Print help when OPT__help_ is set. */
2265 print_help (struct gcc_options
*opts
, unsigned int lang_mask
,
2266 const char *help_option_argument
)
2268 const char *a
= help_option_argument
;
2269 unsigned int include_flags
= 0;
2270 /* Note - by default we include undocumented options when listing
2271 specific classes. If you only want to see documented options
2272 then add ",^undocumented" to the --help= option. E.g.:
2274 --help=target,^undocumented */
2275 unsigned int exclude_flags
= 0;
2277 if (lang_mask
== CL_DRIVER
)
2280 /* Walk along the argument string, parsing each word in turn.
2282 arg = [^]{word}[,{arg}]
2283 word = {optimizers|target|warnings|undocumented|
2284 params|common|<language>} */
2294 { "optimizers", CL_OPTIMIZATION
},
2295 { "target", CL_TARGET
},
2296 { "warnings", CL_WARNING
},
2297 { "undocumented", CL_UNDOCUMENTED
},
2298 { "params", CL_PARAMS
},
2299 { "joined", CL_JOINED
},
2300 { "separate", CL_SEPARATE
},
2301 { "common", CL_COMMON
},
2304 unsigned int *pflags
;
2306 unsigned int lang_flag
, specific_flag
;
2315 error ("missing argument to %qs", "--help=^");
2318 pflags
= &exclude_flags
;
2321 pflags
= &include_flags
;
2323 comma
= strchr (a
, ',');
2334 /* Check to see if the string matches an option class name. */
2335 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
2336 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
2338 specific_flag
= specifics
[i
].flag
;
2342 /* Check to see if the string matches a language name.
2343 Note - we rely upon the alpha-sorted nature of the entries in
2344 the lang_names array, specifically that shorter names appear
2345 before their longer variants. (i.e. C before C++). That way
2346 when we are attempting to match --help=c for example we will
2347 match with C first and not C++. */
2348 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
2349 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
2351 lang_flag
= 1U << i
;
2355 if (specific_flag
!= 0)
2358 *pflags
|= specific_flag
;
2361 /* The option's argument matches both the start of a
2362 language name and the start of an option class name.
2363 We have a special case for when the user has
2364 specified "--help=c", but otherwise we have to issue
2366 if (strncasecmp (a
, "c", len
) == 0)
2367 *pflags
|= lang_flag
;
2370 "%<--help%> argument %q.*s is ambiguous, "
2371 "please be more specific",
2375 else if (lang_flag
!= 0)
2376 *pflags
|= lang_flag
;
2379 "unrecognized argument to %<--help=%> option: %q.*s",
2387 /* We started using PerFunction/Optimization for parameters and
2388 a warning. We should exclude these from optimization options. */
2389 if (include_flags
& CL_OPTIMIZATION
)
2390 exclude_flags
|= CL_WARNING
;
2391 if (!(include_flags
& CL_PARAMS
))
2392 exclude_flags
|= CL_PARAMS
;
2395 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
2399 /* Handle target- and language-independent options. Return zero to
2400 generate an "unknown option" message. Only options that need
2401 extra handling need to be listed here; if you simply want
2402 DECODED->value assigned to a variable, it happens automatically. */
2405 common_handle_option (struct gcc_options
*opts
,
2406 struct gcc_options
*opts_set
,
2407 const struct cl_decoded_option
*decoded
,
2408 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
2410 const struct cl_option_handlers
*handlers
,
2411 diagnostic_context
*dc
,
2412 void (*target_option_override_hook
) (void))
2414 size_t scode
= decoded
->opt_index
;
2415 const char *arg
= decoded
->arg
;
2416 HOST_WIDE_INT value
= decoded
->value
;
2417 enum opt_code code
= (enum opt_code
) scode
;
2419 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
2425 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
2426 unsigned int undoc_mask
;
2429 if (lang_mask
== CL_DRIVER
)
2432 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
2435 target_option_override_hook ();
2436 /* First display any single language specific options. */
2437 for (i
= 0; i
< cl_lang_count
; i
++)
2439 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
2441 /* Next display any multi language specific options. */
2442 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
2443 /* Then display any remaining, non-language options. */
2444 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
2446 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
2447 opts
->x_exit_after_options
= true;
2451 case OPT__target_help
:
2452 if (lang_mask
== CL_DRIVER
)
2455 target_option_override_hook ();
2456 print_specific_help (CL_TARGET
, CL_UNDOCUMENTED
, 0, opts
, lang_mask
);
2457 opts
->x_exit_after_options
= true;
2462 help_option_arguments
.safe_push (arg
);
2463 opts
->x_exit_after_options
= true;
2468 if (lang_mask
== CL_DRIVER
)
2471 opts
->x_exit_after_options
= true;
2474 case OPT__completion_
:
2477 case OPT_fsanitize_
:
2478 opts
->x_flag_sanitize
2479 = parse_sanitizer_options (arg
, loc
, code
,
2480 opts
->x_flag_sanitize
, value
, true);
2482 /* Kernel ASan implies normal ASan but does not yet support
2484 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
2486 SET_OPTION_IF_UNSET (opts
, opts_set
,
2487 param_asan_instrumentation_with_call_threshold
,
2489 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_globals
, 0);
2490 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_stack
, 0);
2491 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_protect_allocas
, 0);
2492 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_use_after_return
, 0);
2494 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_HWADDRESS
)
2496 SET_OPTION_IF_UNSET (opts
, opts_set
,
2497 param_hwasan_instrument_stack
, 0);
2498 SET_OPTION_IF_UNSET (opts
, opts_set
,
2499 param_hwasan_random_frame_tag
, 0);
2500 SET_OPTION_IF_UNSET (opts
, opts_set
,
2501 param_hwasan_instrument_allocas
, 0);
2505 case OPT_fsanitize_recover_
:
2506 opts
->x_flag_sanitize_recover
2507 = parse_sanitizer_options (arg
, loc
, code
,
2508 opts
->x_flag_sanitize_recover
, value
, true);
2511 case OPT_fasan_shadow_offset_
:
2515 case OPT_fsanitize_address_use_after_scope
:
2516 opts
->x_flag_sanitize_address_use_after_scope
= value
;
2519 case OPT_fsanitize_recover
:
2521 opts
->x_flag_sanitize_recover
2522 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)
2523 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2525 opts
->x_flag_sanitize_recover
2526 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2529 case OPT_fsanitize_coverage_
:
2530 opts
->x_flag_sanitize_coverage
2531 = parse_sanitizer_options (arg
, loc
, code
,
2532 opts
->x_flag_sanitize_coverage
, value
, true);
2539 /* Currently handled in a prescan. */
2543 dc
->warning_as_error_requested
= value
;
2547 if (lang_mask
== CL_DRIVER
)
2550 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
2551 opts
, opts_set
, loc
, dc
);
2554 case OPT_Wfatal_errors
:
2555 dc
->fatal_errors
= value
;
2558 case OPT_Wstack_usage_
:
2559 opts
->x_flag_stack_usage_info
= value
!= -1;
2562 case OPT_Wstrict_aliasing
:
2563 set_Wstrict_aliasing (opts
, value
);
2566 case OPT_Wstrict_overflow
:
2567 opts
->x_warn_strict_overflow
= (value
2568 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2572 case OPT_Wsystem_headers
:
2573 dc
->dc_warn_system_headers
= value
;
2577 opts
->x_flag_gen_aux_info
= 1;
2581 decode_d_option (arg
, opts
, loc
, dc
);
2584 case OPT_fcall_used_
:
2585 case OPT_fcall_saved_
:
2593 case OPT_fdebug_prefix_map_
:
2594 case OPT_ffile_prefix_map_
:
2598 case OPT_fcallgraph_info
:
2599 opts
->x_flag_callgraph_info
= CALLGRAPH_INFO_NAKED
;
2602 case OPT_fcallgraph_info_
:
2605 my_arg
= xstrdup (arg
);
2606 p
= strtok (my_arg
, ",");
2609 if (strcmp (p
, "su") == 0)
2611 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_STACK_USAGE
;
2612 opts
->x_flag_stack_usage_info
= true;
2614 else if (strcmp (p
, "da") == 0)
2615 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_DYNAMIC_ALLOC
;
2618 p
= strtok (NULL
, ",");
2624 case OPT_fdiagnostics_show_location_
:
2625 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2628 case OPT_fdiagnostics_show_caret
:
2629 dc
->show_caret
= value
;
2632 case OPT_fdiagnostics_show_labels
:
2633 dc
->show_labels_p
= value
;
2636 case OPT_fdiagnostics_show_line_numbers
:
2637 dc
->show_line_numbers_p
= value
;
2640 case OPT_fdiagnostics_color_
:
2641 diagnostic_color_init (dc
, value
);
2644 case OPT_fdiagnostics_urls_
:
2645 diagnostic_urls_init (dc
, value
);
2648 case OPT_fdiagnostics_format_
:
2649 diagnostic_output_format_init (dc
,
2650 (enum diagnostics_output_format
)value
);
2653 case OPT_fdiagnostics_parseable_fixits
:
2654 dc
->extra_output_kind
= (value
2655 ? EXTRA_DIAGNOSTIC_OUTPUT_fixits_v1
2656 : EXTRA_DIAGNOSTIC_OUTPUT_none
);
2659 case OPT_fdiagnostics_column_unit_
:
2660 dc
->column_unit
= (enum diagnostics_column_unit
)value
;
2663 case OPT_fdiagnostics_column_origin_
:
2664 dc
->column_origin
= value
;
2667 case OPT_fdiagnostics_show_cwe
:
2668 dc
->show_cwe
= value
;
2671 case OPT_fdiagnostics_path_format_
:
2672 dc
->path_format
= (enum diagnostic_path_format
)value
;
2675 case OPT_fdiagnostics_show_path_depths
:
2676 dc
->show_path_depths
= value
;
2679 case OPT_fdiagnostics_show_option
:
2680 dc
->show_option_requested
= value
;
2683 case OPT_fdiagnostics_minimum_margin_width_
:
2684 dc
->min_margin_width
= value
;
2691 case OPT_ffast_math
:
2692 set_fast_math_flags (opts
, value
);
2695 case OPT_funsafe_math_optimizations
:
2696 set_unsafe_math_optimizations_flags (opts
, value
);
2703 case OPT_finline_limit_
:
2704 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_single
,
2706 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_auto
,
2710 case OPT_finstrument_functions_exclude_function_list_
:
2711 add_comma_separated_to_vector
2712 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2715 case OPT_finstrument_functions_exclude_file_list_
:
2716 add_comma_separated_to_vector
2717 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2720 case OPT_fmessage_length_
:
2721 pp_set_line_maximum_length (dc
->printer
, value
);
2722 diagnostic_set_caret_max_width (dc
, value
);
2726 case OPT_fopt_info_
:
2734 #ifndef ACCEL_COMPILER
2735 case OPT_foffload_abi_
:
2736 error_at (loc
, "%<-foffload-abi%> option can be specified only for "
2737 "offload compiler");
2741 case OPT_fpack_struct_
:
2742 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2744 "structure alignment must be a small power of two, not %wu",
2747 opts
->x_initial_max_fld_align
= value
;
2751 case OPT_fplugin_arg_
:
2755 case OPT_fprofile_use_
:
2756 opts
->x_profile_data_prefix
= xstrdup (arg
);
2757 opts
->x_flag_profile_use
= true;
2759 /* No break here - do -fprofile-use processing. */
2761 case OPT_fprofile_use
:
2762 enable_fdo_optimizations (opts
, opts_set
, value
);
2763 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_reorder_functions
,
2765 /* Indirect call profiling should do all useful transformations
2766 speculative devirtualization does. */
2767 if (opts
->x_flag_value_profile_transformations
)
2768 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_devirtualize_speculatively
,
2772 case OPT_fauto_profile_
:
2773 opts
->x_auto_profile_file
= xstrdup (arg
);
2774 opts
->x_flag_auto_profile
= true;
2776 /* No break here - do -fauto-profile processing. */
2778 case OPT_fauto_profile
:
2779 enable_fdo_optimizations (opts
, opts_set
, value
);
2780 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_correction
, value
);
2781 SET_OPTION_IF_UNSET (opts
, opts_set
,
2782 param_early_inliner_max_iterations
, 10);
2785 case OPT_fprofile_generate_
:
2786 opts
->x_profile_data_prefix
= xstrdup (arg
);
2788 /* No break here - do -fprofile-generate processing. */
2790 case OPT_fprofile_generate
:
2791 SET_OPTION_IF_UNSET (opts
, opts_set
, profile_arc_flag
, value
);
2792 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
2793 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
2794 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, value
);
2797 case OPT_fprofile_info_section
:
2798 opts
->x_profile_info_section
= ".gcov_info";
2801 case OPT_fpatchable_function_entry_
:
2803 HOST_WIDE_INT patch_area_size
, patch_area_start
;
2804 parse_and_check_patch_area (arg
, true, &patch_area_size
,
2809 case OPT_ftree_vectorize
:
2810 /* Automatically sets -ftree-loop-vectorize and
2811 -ftree-slp-vectorize. Nothing more to do here. */
2813 case OPT_fzero_call_used_regs_
:
2814 opts
->x_flag_zero_call_used_regs
2815 = parse_zero_call_used_regs_options (arg
);
2818 case OPT_fshow_column
:
2819 dc
->show_column
= value
;
2822 case OPT_frandom_seed
:
2823 /* The real switch is -fno-random-seed. */
2829 case OPT_frandom_seed_
:
2833 case OPT_fsched_verbose_
:
2834 #ifdef INSN_SCHEDULING
2835 /* Handled with Var in common.opt. */
2841 case OPT_fsched_stalled_insns_
:
2842 opts
->x_flag_sched_stalled_insns
= value
;
2843 if (opts
->x_flag_sched_stalled_insns
== 0)
2844 opts
->x_flag_sched_stalled_insns
= -1;
2847 case OPT_fsched_stalled_insns_dep_
:
2848 opts
->x_flag_sched_stalled_insns_dep
= value
;
2851 case OPT_fstack_check_
:
2852 if (!strcmp (arg
, "no"))
2853 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
2854 else if (!strcmp (arg
, "generic"))
2855 /* This is the old stack checking method. */
2856 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2857 ? FULL_BUILTIN_STACK_CHECK
2858 : GENERIC_STACK_CHECK
;
2859 else if (!strcmp (arg
, "specific"))
2860 /* This is the new stack checking method. */
2861 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2862 ? FULL_BUILTIN_STACK_CHECK
2863 : STACK_CHECK_STATIC_BUILTIN
2864 ? STATIC_BUILTIN_STACK_CHECK
2865 : GENERIC_STACK_CHECK
;
2867 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
2870 case OPT_fstack_limit
:
2871 /* The real switch is -fno-stack-limit. */
2877 case OPT_fstack_limit_register_
:
2878 case OPT_fstack_limit_symbol_
:
2882 case OPT_fstack_usage
:
2883 opts
->x_flag_stack_usage
= value
;
2884 opts
->x_flag_stack_usage_info
= value
!= 0;
2888 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
2893 if (arg
&& strlen (arg
) != 0)
2895 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
2896 "use %<-gdwarf-%s%> for DWARF version "
2897 "or %<-gdwarf%> %<-g%s%> for debug level", arg
, arg
, arg
);
2901 value
= opts
->x_dwarf_version
;
2905 if (value
< 2 || value
> 5)
2906 error_at (loc
, "dwarf version %wu is not supported", value
);
2908 opts
->x_dwarf_version
= value
;
2909 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
2913 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
2918 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
, opts
, opts_set
,
2923 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2928 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
, opts
, opts_set
,
2934 /* Handled completely via specs. */
2937 case OPT_pedantic_errors
:
2938 dc
->pedantic_errors
= 1;
2939 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
2941 handlers
, opts
, opts_set
,
2946 opts
->x_flag_lto
= value
? "" : NULL
;
2950 if (strcmp (arg
, "none") != 0
2951 && strcmp (arg
, "jobserver") != 0
2952 && strcmp (arg
, "auto") != 0
2955 "unrecognized argument to %<-flto=%> option: %qs", arg
);
2959 dc
->dc_inhibit_warnings
= true;
2962 case OPT_fmax_errors_
:
2963 dc
->max_errors
= value
;
2966 case OPT_fuse_ld_bfd
:
2967 case OPT_fuse_ld_gold
:
2968 case OPT_fuse_ld_lld
:
2969 case OPT_fuse_linker_plugin
:
2970 /* No-op. Used by the driver and passed to us because it starts with f.*/
2975 opts
->x_flag_trapv
= 0;
2980 opts
->x_flag_wrapv
= 0;
2983 case OPT_fstrict_overflow
:
2984 opts
->x_flag_wrapv
= !value
;
2985 opts
->x_flag_wrapv_pointer
= !value
;
2987 opts
->x_flag_trapv
= 0;
2991 opts
->x_flag_ipa_icf_functions
= value
;
2992 opts
->x_flag_ipa_icf_variables
= value
;
2995 case OPT_falign_loops_
:
2996 check_alignment_argument (loc
, arg
, "loops",
2997 &opts
->x_flag_align_loops
,
2998 &opts
->x_str_align_loops
);
3001 case OPT_falign_jumps_
:
3002 check_alignment_argument (loc
, arg
, "jumps",
3003 &opts
->x_flag_align_jumps
,
3004 &opts
->x_str_align_jumps
);
3007 case OPT_falign_labels_
:
3008 check_alignment_argument (loc
, arg
, "labels",
3009 &opts
->x_flag_align_labels
,
3010 &opts
->x_str_align_labels
);
3013 case OPT_falign_functions_
:
3014 check_alignment_argument (loc
, arg
, "functions",
3015 &opts
->x_flag_align_functions
,
3016 &opts
->x_str_align_functions
);
3020 /* It is documented that we silently ignore silly values. */
3021 if (value
>= 1 && value
<= 100)
3022 dc
->tabstop
= value
;
3026 /* If the flag was handled in a standard way, assume the lack of
3027 processing here is intentional. */
3028 gcc_assert (option_flag_var (scode
, opts
));
3032 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
3037 /* Used to set the level of strict aliasing warnings in OPTS,
3038 when no level is specified (i.e., when -Wstrict-aliasing, and not
3039 -Wstrict-aliasing=level was given).
3040 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
3041 and 0 otherwise. After calling this function, wstrict_aliasing will be
3042 set to the default value of -Wstrict_aliasing=level, currently 3. */
3044 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
3046 gcc_assert (onoff
== 0 || onoff
== 1);
3048 opts
->x_warn_strict_aliasing
= 3;
3050 opts
->x_warn_strict_aliasing
= 0;
3053 /* The following routines are useful in setting all the flags that
3054 -ffast-math and -fno-fast-math imply. */
3056 set_fast_math_flags (struct gcc_options
*opts
, int set
)
3058 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
3060 opts
->x_flag_unsafe_math_optimizations
= set
;
3061 set_unsafe_math_optimizations_flags (opts
, set
);
3063 if (!opts
->frontend_set_flag_finite_math_only
)
3064 opts
->x_flag_finite_math_only
= set
;
3065 if (!opts
->frontend_set_flag_errno_math
)
3066 opts
->x_flag_errno_math
= !set
;
3069 if (opts
->frontend_set_flag_excess_precision
== EXCESS_PRECISION_DEFAULT
)
3070 opts
->x_flag_excess_precision
3071 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
3072 if (!opts
->frontend_set_flag_signaling_nans
)
3073 opts
->x_flag_signaling_nans
= 0;
3074 if (!opts
->frontend_set_flag_rounding_math
)
3075 opts
->x_flag_rounding_math
= 0;
3076 if (!opts
->frontend_set_flag_cx_limited_range
)
3077 opts
->x_flag_cx_limited_range
= 1;
3081 /* When -funsafe-math-optimizations is set the following
3082 flags are set as well. */
3084 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
3086 if (!opts
->frontend_set_flag_trapping_math
)
3087 opts
->x_flag_trapping_math
= !set
;
3088 if (!opts
->frontend_set_flag_signed_zeros
)
3089 opts
->x_flag_signed_zeros
= !set
;
3090 if (!opts
->frontend_set_flag_associative_math
)
3091 opts
->x_flag_associative_math
= set
;
3092 if (!opts
->frontend_set_flag_reciprocal_math
)
3093 opts
->x_flag_reciprocal_math
= set
;
3096 /* Return true iff flags in OPTS are set as if -ffast-math. */
3098 fast_math_flags_set_p (const struct gcc_options
*opts
)
3100 return (!opts
->x_flag_trapping_math
3101 && opts
->x_flag_unsafe_math_optimizations
3102 && opts
->x_flag_finite_math_only
3103 && !opts
->x_flag_signed_zeros
3104 && !opts
->x_flag_errno_math
3105 && opts
->x_flag_excess_precision
== EXCESS_PRECISION_FAST
);
3108 /* Return true iff flags are set as if -ffast-math but using the flags stored
3109 in the struct cl_optimization structure. */
3111 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
3113 return (!opt
->x_flag_trapping_math
3114 && opt
->x_flag_unsafe_math_optimizations
3115 && opt
->x_flag_finite_math_only
3116 && !opt
->x_flag_signed_zeros
3117 && !opt
->x_flag_errno_math
);
3120 /* Handle a debug output -g switch for options OPTS
3121 (OPTS_SET->x_write_symbols storing whether a debug format was passed
3122 explicitly), location LOC. EXTENDED is true or false to support
3123 extended output (2 is special and means "-ggdb" was given). */
3125 set_debug_level (uint32_t dinfo
, int extended
, const char *arg
,
3126 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
3129 opts
->x_use_gnu_debug_info_extensions
= extended
;
3131 if (dinfo
== NO_DEBUG
)
3133 if (opts
->x_write_symbols
== NO_DEBUG
)
3135 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
3139 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
3140 opts
->x_write_symbols
= DWARF2_DEBUG
;
3141 #elif defined DBX_DEBUGGING_INFO
3142 opts
->x_write_symbols
= DBX_DEBUG
;
3146 if (opts
->x_write_symbols
== NO_DEBUG
)
3147 warning_at (loc
, 0, "target system does not support debug output");
3152 /* Does it conflict with an already selected debug format? */
3153 if (opts_set
->x_write_symbols
!= NO_DEBUG
3154 && opts
->x_write_symbols
!= NO_DEBUG
3155 && dinfo
!= opts
->x_write_symbols
)
3157 gcc_assert (debug_set_count (dinfo
) <= 1);
3158 error_at (loc
, "debug format %qs conflicts with prior selection",
3159 debug_type_names
[debug_set_to_format (dinfo
)]);
3162 opts
->x_write_symbols
= dinfo
;
3163 opts_set
->x_write_symbols
= dinfo
;
3166 /* A debug flag without a level defaults to level 2.
3167 If off or at level 1, set it to level 2, but if already
3168 at level 3, don't lower it. */
3171 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
3172 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3176 int argval
= integral_argument (arg
);
3178 error_at (loc
, "unrecognized debug output level %qs", arg
);
3179 else if (argval
> 3)
3180 error_at (loc
, "debug output level %qs is too high", arg
);
3182 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
3186 /* Arrange to dump core on error for diagnostic context DC. (The
3187 regular error message is still printed first, except in the case of
3191 setup_core_dumping (diagnostic_context
*dc
)
3194 signal (SIGABRT
, SIG_DFL
);
3196 #if defined(HAVE_SETRLIMIT)
3199 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
3200 fatal_error (input_location
, "getting core file size maximum limit: %m");
3201 rlim
.rlim_cur
= rlim
.rlim_max
;
3202 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
3203 fatal_error (input_location
,
3204 "setting core file size limit to maximum: %m");
3207 diagnostic_abort_on_error (dc
);
3210 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
3211 diagnostic context DC. */
3214 decode_d_option (const char *arg
, struct gcc_options
*opts
,
3215 location_t loc
, diagnostic_context
*dc
)
3223 opts
->x_flag_debug_asm
= 1;
3226 opts
->x_flag_print_asm_name
= 1;
3229 opts
->x_flag_dump_rtl_in_asm
= 1;
3230 opts
->x_flag_print_asm_name
= 1;
3233 opts
->x_rtl_dump_and_exit
= 1;
3235 case 'D': /* These are handled by the preprocessor. */
3242 setup_core_dumping (dc
);
3245 opts
->x_flag_dump_all_passed
= true;
3249 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
3254 /* Enable (or disable if VALUE is 0) a warning option ARG (language
3255 mask LANG_MASK, option handlers HANDLERS) as an error for option
3256 structures OPTS and OPTS_SET, diagnostic context DC (possibly
3257 NULL), location LOC. This is used by -Werror=. */
3260 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
3261 const struct cl_option_handlers
*handlers
,
3262 struct gcc_options
*opts
,
3263 struct gcc_options
*opts_set
,
3264 location_t loc
, diagnostic_context
*dc
)
3269 new_option
= XNEWVEC (char, strlen (arg
) + 2);
3270 new_option
[0] = 'W';
3271 strcpy (new_option
+ 1, arg
);
3272 option_index
= find_opt (new_option
, lang_mask
);
3273 if (option_index
== OPT_SPECIAL_unknown
)
3276 const char *hint
= op
.suggest_option (new_option
);
3278 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>;"
3279 " did you mean %<-%s%>?", value
? "" : "no-",
3280 arg
, new_option
, hint
);
3282 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>",
3283 value
? "" : "no-", arg
, new_option
);
3285 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
3286 error_at (loc
, "%<-Werror=%s%>: %<-%s%> is not an option that "
3287 "controls warnings", arg
, new_option
);
3290 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
3291 const char *arg
= NULL
;
3293 if (cl_options
[option_index
].flags
& CL_JOINED
)
3294 arg
= new_option
+ cl_options
[option_index
].opt_len
;
3295 control_warning_option (option_index
, (int) kind
, arg
, value
,
3297 handlers
, opts
, opts_set
, dc
);
3302 /* Return malloced memory for the name of the option OPTION_INDEX
3303 which enabled a diagnostic (context CONTEXT), originally of type
3304 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
3308 option_name (diagnostic_context
*context
, int option_index
,
3309 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
3313 /* A warning classified as an error. */
3314 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
3315 && diag_kind
== DK_ERROR
)
3316 return concat (cl_options
[OPT_Werror_
].opt_text
,
3317 /* Skip over "-W". */
3318 cl_options
[option_index
].opt_text
+ 2,
3320 /* A warning with option. */
3322 return xstrdup (cl_options
[option_index
].opt_text
);
3324 /* A warning without option classified as an error. */
3325 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
3326 || diag_kind
== DK_WARNING
)
3327 && context
->warning_as_error_requested
)
3328 return xstrdup (cl_options
[OPT_Werror
].opt_text
);
3333 /* Get the page within the documentation for this option. */
3336 get_option_html_page (int option_index
)
3338 const cl_option
*cl_opt
= &cl_options
[option_index
];
3340 /* Analyzer options are on their own page. */
3341 if (strstr (cl_opt
->opt_text
, "analyzer-"))
3342 return "gcc/Static-Analyzer-Options.html";
3344 /* Handle -flto= option. */
3345 if (strstr (cl_opt
->opt_text
, "flto"))
3346 return "gcc/Optimize-Options.html";
3349 if ((cl_opt
->flags
& CL_Fortran
) != 0
3350 /* If it is option common to both C/C++ and Fortran, it is documented
3351 in gcc/ rather than gfortran/ docs. */
3352 && (cl_opt
->flags
& CL_C
) == 0
3354 && (cl_opt
->flags
& CL_CXX
) == 0
3357 return "gfortran/Error-and-Warning-Options.html";
3360 return "gcc/Warning-Options.html";
3363 /* Return malloced memory for a URL describing the option OPTION_INDEX
3364 which enabled a diagnostic (context CONTEXT). */
3367 get_option_url (diagnostic_context
*, int option_index
)
3370 return concat (/* DOCUMENTATION_ROOT_URL should be supplied via -D by
3371 the Makefile (see --with-documentation-root-url), and
3372 should have a trailing slash. */
3373 DOCUMENTATION_ROOT_URL
,
3375 /* get_option_html_page will return something like
3376 "gcc/Warning-Options.html". */
3377 get_option_html_page (option_index
),
3379 /* Expect an anchor of the form "index-Wfoo" e.g.
3380 <a name="index-Wformat"></a>, and thus an id within
3381 the URL of "#index-Wformat". */
3382 "#index", cl_options
[option_index
].opt_text
,
3388 /* Return a heap allocated producer with command line options. */
3391 gen_command_line_string (cl_decoded_option
*options
,
3392 unsigned int options_count
)
3394 auto_vec
<const char *> switches
;
3395 char *options_string
, *tail
;
3399 for (unsigned i
= 0; i
< options_count
; i
++)
3400 switch (options
[i
].opt_index
)
3405 case OPT_dumpbase_ext
:
3415 case OPT_SPECIAL_unknown
:
3416 case OPT_SPECIAL_ignore
:
3417 case OPT_SPECIAL_warn_removed
:
3418 case OPT_SPECIAL_program_name
:
3419 case OPT_SPECIAL_input_file
:
3420 case OPT_grecord_gcc_switches
:
3421 case OPT_frecord_gcc_switches
:
3422 case OPT__output_pch_
:
3423 case OPT_fdiagnostics_show_location_
:
3424 case OPT_fdiagnostics_show_option
:
3425 case OPT_fdiagnostics_show_caret
:
3426 case OPT_fdiagnostics_show_labels
:
3427 case OPT_fdiagnostics_show_line_numbers
:
3428 case OPT_fdiagnostics_color_
:
3429 case OPT_fdiagnostics_format_
:
3430 case OPT_fverbose_asm
:
3434 case OPT_nostdinc__
:
3435 case OPT_fpreprocessed
:
3436 case OPT_fltrans_output_list_
:
3437 case OPT_fresolution_
:
3438 case OPT_fdebug_prefix_map_
:
3439 case OPT_fmacro_prefix_map_
:
3440 case OPT_ffile_prefix_map_
:
3441 case OPT_fcompare_debug
:
3443 case OPT_fchecking_
:
3448 const char *lto_canonical
= "-flto";
3449 switches
.safe_push (lto_canonical
);
3450 len
+= strlen (lto_canonical
) + 1;
3454 if (cl_options
[options
[i
].opt_index
].flags
3455 & CL_NO_DWARF_RECORD
)
3457 gcc_checking_assert (options
[i
].canonical_option
[0][0] == '-');
3458 switch (options
[i
].canonical_option
[0][1])
3465 if (strncmp (options
[i
].canonical_option
[0] + 2,
3472 switches
.safe_push (options
[i
].orig_option_with_args_text
);
3473 len
+= strlen (options
[i
].orig_option_with_args_text
) + 1;
3477 options_string
= XNEWVEC (char, len
+ 1);
3478 tail
= options_string
;
3481 FOR_EACH_VEC_ELT (switches
, i
, p
)
3484 memcpy (tail
, p
, len
);
3486 if (i
!= switches
.length () - 1)
3494 return options_string
;
3497 /* Return a heap allocated producer string including command line options. */
3500 gen_producer_string (const char *language_string
, cl_decoded_option
*options
,
3501 unsigned int options_count
)
3503 char *cmdline
= gen_command_line_string (options
, options_count
);
3504 char *combined
= concat (language_string
, " ", version_string
, " ",
3512 namespace selftest
{
3514 /* Verify that get_option_html_page works as expected. */
3517 test_get_option_html_page ()
3519 ASSERT_STREQ (get_option_html_page (OPT_Wcpp
), "gcc/Warning-Options.html");
3520 ASSERT_STREQ (get_option_html_page (OPT_Wanalyzer_double_free
),
3521 "gcc/Static-Analyzer-Options.html");
3523 ASSERT_STREQ (get_option_html_page (OPT_Wline_truncation
),
3524 "gfortran/Error-and-Warning-Options.html");
3528 /* Run all of the selftests within this file. */
3533 test_get_option_html_page ();
3536 } // namespace selftest
3538 #endif /* #if CHECKING_P */