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", "ctf", "btf"
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
,
57 /* Names of the set of debug formats requested by user. Updated and accessed
58 via debug_set_names. */
60 static char df_set_names
[sizeof "none stabs dwarf-2 xcoff vms ctf btf"];
62 /* Get enum debug_info_type of the specified debug format, for error messages.
63 Can be used only for individual debug format types. */
66 debug_set_to_format (uint32_t debug_info_set
)
69 enum debug_info_type dinfo_type
= DINFO_TYPE_NONE
;
70 /* Find first set bit. */
72 idx
= exact_log2 (debug_info_set
& - debug_info_set
);
73 /* Check that only one bit is set, if at all. This function is meant to be
74 used only for vanilla debug_info_set bitmask values, i.e. for individual
75 debug format types upto DINFO_TYPE_MAX. */
76 gcc_assert ((debug_info_set
& (debug_info_set
- 1)) == 0);
77 dinfo_type
= (enum debug_info_type
)idx
;
78 gcc_assert (dinfo_type
<= DINFO_TYPE_MAX
);
82 /* Get the number of debug formats enabled for output. */
85 debug_set_count (uint32_t w_symbols
)
87 unsigned int count
= 0;
91 w_symbols
&= ~ (w_symbols
& - w_symbols
);
96 /* Get the names of the debug formats enabled for output. */
99 debug_set_names (uint32_t w_symbols
)
101 uint32_t df_mask
= 0;
102 /* Reset the string to be returned. */
103 memset (df_set_names
, 0, sizeof (df_set_names
));
104 /* Get the popcount. */
105 int num_set_df
= debug_set_count (w_symbols
);
106 /* Iterate over the debug formats. Add name string for those enabled. */
107 for (int i
= DINFO_TYPE_NONE
; i
<= DINFO_TYPE_MAX
; i
++)
109 df_mask
= debug_type_masks
[i
];
110 if (w_symbols
& df_mask
)
112 strcat (df_set_names
, debug_type_names
[i
]);
115 strcat (df_set_names
, " ");
121 /* No debug formats enabled. */
122 gcc_assert (i
== DINFO_TYPE_NONE
);
123 strcat (df_set_names
, debug_type_names
[i
]);
130 /* Return TRUE iff BTF debug info is enabled. */
135 return (write_symbols
& BTF_DEBUG
);
138 /* Return TRUE iff BTF with CO-RE debug info is enabled. */
141 btf_with_core_debuginfo_p ()
143 return (write_symbols
& BTF_WITH_CORE_DEBUG
);
146 /* Return TRUE iff CTF debug info is enabled. */
151 return (write_symbols
& CTF_DEBUG
);
154 /* Return TRUE iff dwarf2 debug info is enabled. */
159 return (write_symbols
& DWARF2_DEBUG
);
162 /* Return true iff the debug info format is to be generated based on DWARF
163 DIEs (like CTF and BTF debug info formats). */
165 bool dwarf_based_debuginfo_p ()
167 return ((write_symbols
& CTF_DEBUG
)
168 || (write_symbols
& BTF_DEBUG
));
171 /* Parse the -femit-struct-debug-detailed option value
172 and set the flag variables. */
174 #define MATCH( prefix, string ) \
175 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
176 ? ((string += sizeof prefix - 1), 1) : 0)
179 set_struct_debug_option (struct gcc_options
*opts
, location_t loc
,
182 /* various labels for comparison */
183 static const char dfn_lbl
[] = "dfn:", dir_lbl
[] = "dir:", ind_lbl
[] = "ind:";
184 static const char ord_lbl
[] = "ord:", gen_lbl
[] = "gen:";
185 static const char none_lbl
[] = "none", any_lbl
[] = "any";
186 static const char base_lbl
[] = "base", sys_lbl
[] = "sys";
188 enum debug_struct_file files
= DINFO_STRUCT_FILE_ANY
;
189 /* Default is to apply to as much as possible. */
190 enum debug_info_usage usage
= DINFO_USAGE_NUM_ENUMS
;
191 int ord
= 1, gen
= 1;
194 if (MATCH (dfn_lbl
, spec
))
195 usage
= DINFO_USAGE_DFN
;
196 else if (MATCH (dir_lbl
, spec
))
197 usage
= DINFO_USAGE_DIR_USE
;
198 else if (MATCH (ind_lbl
, spec
))
199 usage
= DINFO_USAGE_IND_USE
;
201 /* Generics or not? */
202 if (MATCH (ord_lbl
, spec
))
204 else if (MATCH (gen_lbl
, spec
))
207 /* What allowable environment? */
208 if (MATCH (none_lbl
, spec
))
209 files
= DINFO_STRUCT_FILE_NONE
;
210 else if (MATCH (any_lbl
, spec
))
211 files
= DINFO_STRUCT_FILE_ANY
;
212 else if (MATCH (sys_lbl
, spec
))
213 files
= DINFO_STRUCT_FILE_SYS
;
214 else if (MATCH (base_lbl
, spec
))
215 files
= DINFO_STRUCT_FILE_BASE
;
218 "argument %qs to %<-femit-struct-debug-detailed%> "
222 /* Effect the specification. */
223 if (usage
== DINFO_USAGE_NUM_ENUMS
)
227 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DFN
] = files
;
228 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
] = files
;
229 opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
] = files
;
233 opts
->x_debug_struct_generic
[DINFO_USAGE_DFN
] = files
;
234 opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
] = files
;
235 opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
] = files
;
241 opts
->x_debug_struct_ordinary
[usage
] = files
;
243 opts
->x_debug_struct_generic
[usage
] = files
;
247 set_struct_debug_option (opts
, loc
, spec
+1);
250 /* No more -femit-struct-debug-detailed specifications.
254 "argument %qs to %<-femit-struct-debug-detailed%> unknown",
256 if (opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
]
257 < opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
]
258 || opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
]
259 < opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
])
261 "%<-femit-struct-debug-detailed=dir:...%> must allow "
262 "at least as much as "
263 "%<-femit-struct-debug-detailed=ind:...%>");
267 /* Strip off a legitimate source ending from the input string NAME of
268 length LEN. Rather than having to know the names used by all of
269 our front ends, we strip off an ending of a period followed by
270 up to fource characters. (C++ uses ".cpp".) */
273 strip_off_ending (char *name
, int len
)
276 for (i
= 2; i
< 5 && len
> i
; i
++)
278 if (name
[len
- i
] == '.')
280 name
[len
- i
] = '\0';
286 /* Find the base name of a path, stripping off both directories and
287 a single final extension. */
289 base_of_path (const char *path
, const char **base_out
)
291 const char *base
= path
;
293 const char *p
= path
;
297 if (IS_DIR_SEPARATOR (c
))
312 /* What to print when a switch has no documentation. */
313 static const char undocumented_msg
[] = N_("This option lacks documentation.");
314 static const char use_diagnosed_msg
[] = N_("Uses of this option are diagnosed.");
316 typedef char *char_p
; /* For DEF_VEC_P. */
318 static void set_debug_level (uint32_t dinfo
, int extended
,
319 const char *arg
, struct gcc_options
*opts
,
320 struct gcc_options
*opts_set
,
322 static void set_fast_math_flags (struct gcc_options
*opts
, int set
);
323 static void decode_d_option (const char *arg
, struct gcc_options
*opts
,
324 location_t loc
, diagnostic_context
*dc
);
325 static void set_unsafe_math_optimizations_flags (struct gcc_options
*opts
,
327 static void enable_warning_as_error (const char *arg
, int value
,
328 unsigned int lang_mask
,
329 const struct cl_option_handlers
*handlers
,
330 struct gcc_options
*opts
,
331 struct gcc_options
*opts_set
,
333 diagnostic_context
*dc
);
335 /* Handle a back-end option; arguments and return value as for
339 target_handle_option (struct gcc_options
*opts
,
340 struct gcc_options
*opts_set
,
341 const struct cl_decoded_option
*decoded
,
342 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
344 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
345 diagnostic_context
*dc
, void (*) (void))
347 gcc_assert (dc
== global_dc
);
348 gcc_assert (kind
== DK_UNSPECIFIED
);
349 return targetm_common
.handle_option (opts
, opts_set
, decoded
, loc
);
352 /* Add comma-separated strings to a char_p vector. */
355 add_comma_separated_to_vector (void **pvec
, const char *arg
)
361 vec
<char_p
> *v
= (vec
<char_p
> *) *pvec
;
363 vec_check_alloc (v
, 1);
365 /* We never free this string. */
378 v
->safe_push (token_start
);
381 if (*r
== '\\' && r
[1] == ',')
391 if (*token_start
!= '\0')
392 v
->safe_push (token_start
);
397 /* Initialize opts_obstack. */
400 init_opts_obstack (void)
402 gcc_obstack_init (&opts_obstack
);
405 /* Initialize OPTS and OPTS_SET before using them in parsing options. */
408 init_options_struct (struct gcc_options
*opts
, struct gcc_options
*opts_set
)
410 /* Ensure that opts_obstack has already been initialized by the time
411 that we initialize any gcc_options instances (PR jit/68446). */
412 gcc_assert (opts_obstack
.chunk_size
> 0);
414 *opts
= global_options_init
;
417 memset (opts_set
, 0, sizeof (*opts_set
));
419 /* Initialize whether `char' is signed. */
420 opts
->x_flag_signed_char
= DEFAULT_SIGNED_CHAR
;
421 /* Set this to a special "uninitialized" value. The actual default
422 is set after target options have been processed. */
423 opts
->x_flag_short_enums
= 2;
425 /* Initialize target_flags before default_options_optimization
426 so the latter can modify it. */
427 opts
->x_target_flags
= targetm_common
.default_target_flags
;
429 /* Some targets have ABI-specified unwind tables. */
430 opts
->x_flag_unwind_tables
= targetm_common
.unwind_tables_default
;
432 /* Some targets have other target-specific initialization. */
433 targetm_common
.option_init_struct (opts
);
436 /* If indicated by the optimization level LEVEL (-Os if SIZE is set,
437 -Ofast if FAST is set, -Og if DEBUG is set), apply the option DEFAULT_OPT
438 to OPTS and OPTS_SET, diagnostic context DC, location LOC, with language
439 mask LANG_MASK and option handlers HANDLERS. */
442 maybe_default_option (struct gcc_options
*opts
,
443 struct gcc_options
*opts_set
,
444 const struct default_options
*default_opt
,
445 int level
, bool size
, bool fast
, bool debug
,
446 unsigned int lang_mask
,
447 const struct cl_option_handlers
*handlers
,
449 diagnostic_context
*dc
)
451 const struct cl_option
*option
= &cl_options
[default_opt
->opt_index
];
455 gcc_assert (level
== 2);
457 gcc_assert (level
== 3);
459 gcc_assert (level
== 1);
461 switch (default_opt
->levels
)
467 case OPT_LEVELS_0_ONLY
:
468 enabled
= (level
== 0);
471 case OPT_LEVELS_1_PLUS
:
472 enabled
= (level
>= 1);
475 case OPT_LEVELS_1_PLUS_SPEED_ONLY
:
476 enabled
= (level
>= 1 && !size
&& !debug
);
479 case OPT_LEVELS_1_PLUS_NOT_DEBUG
:
480 enabled
= (level
>= 1 && !debug
);
483 case OPT_LEVELS_2_PLUS
:
484 enabled
= (level
>= 2);
487 case OPT_LEVELS_2_PLUS_SPEED_ONLY
:
488 enabled
= (level
>= 2 && !size
&& !debug
);
491 case OPT_LEVELS_3_PLUS
:
492 enabled
= (level
>= 3);
495 case OPT_LEVELS_3_PLUS_AND_SIZE
:
496 enabled
= (level
>= 3 || size
);
499 case OPT_LEVELS_SIZE
:
503 case OPT_LEVELS_FAST
:
507 case OPT_LEVELS_NONE
:
513 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
514 default_opt
->arg
, default_opt
->value
,
515 lang_mask
, DK_UNSPECIFIED
, loc
,
517 else if (default_opt
->arg
== NULL
518 && !option
->cl_reject_negative
519 && !(option
->flags
& CL_PARAMS
))
520 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
521 default_opt
->arg
, !default_opt
->value
,
522 lang_mask
, DK_UNSPECIFIED
, loc
,
526 /* As indicated by the optimization level LEVEL (-Os if SIZE is set,
527 -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
528 OPTS and OPTS_SET, diagnostic context DC, location LOC, with
529 language mask LANG_MASK and option handlers HANDLERS. */
532 maybe_default_options (struct gcc_options
*opts
,
533 struct gcc_options
*opts_set
,
534 const struct default_options
*default_opts
,
535 int level
, bool size
, bool fast
, bool debug
,
536 unsigned int lang_mask
,
537 const struct cl_option_handlers
*handlers
,
539 diagnostic_context
*dc
)
543 for (i
= 0; default_opts
[i
].levels
!= OPT_LEVELS_NONE
; i
++)
544 maybe_default_option (opts
, opts_set
, &default_opts
[i
],
545 level
, size
, fast
, debug
,
546 lang_mask
, handlers
, loc
, dc
);
549 /* Table of options enabled by default at different levels.
550 Please keep this list sorted by level and alphabetized within
551 each level; this makes it easier to keep the documentation
554 static const struct default_options default_options_table
[] =
556 /* -O1 and -Og optimizations. */
557 { OPT_LEVELS_1_PLUS
, OPT_fcombine_stack_adjustments
, NULL
, 1 },
558 { OPT_LEVELS_1_PLUS
, OPT_fcompare_elim
, NULL
, 1 },
559 { OPT_LEVELS_1_PLUS
, OPT_fcprop_registers
, NULL
, 1 },
560 { OPT_LEVELS_1_PLUS
, OPT_fdefer_pop
, NULL
, 1 },
561 { OPT_LEVELS_1_PLUS
, OPT_fforward_propagate
, NULL
, 1 },
562 { OPT_LEVELS_1_PLUS
, OPT_fguess_branch_probability
, NULL
, 1 },
563 { OPT_LEVELS_1_PLUS
, OPT_fipa_profile
, NULL
, 1 },
564 { OPT_LEVELS_1_PLUS
, OPT_fipa_pure_const
, NULL
, 1 },
565 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference
, NULL
, 1 },
566 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference_addressable
, NULL
, 1 },
567 { OPT_LEVELS_1_PLUS
, OPT_fmerge_constants
, NULL
, 1 },
568 { OPT_LEVELS_1_PLUS
, OPT_fomit_frame_pointer
, NULL
, 1 },
569 { OPT_LEVELS_1_PLUS
, OPT_freorder_blocks
, NULL
, 1 },
570 { OPT_LEVELS_1_PLUS
, OPT_fshrink_wrap
, NULL
, 1 },
571 { OPT_LEVELS_1_PLUS
, OPT_fsplit_wide_types
, NULL
, 1 },
572 { OPT_LEVELS_1_PLUS
, OPT_fthread_jumps
, NULL
, 1 },
573 { OPT_LEVELS_1_PLUS
, OPT_ftree_builtin_call_dce
, NULL
, 1 },
574 { OPT_LEVELS_1_PLUS
, OPT_ftree_ccp
, NULL
, 1 },
575 { OPT_LEVELS_1_PLUS
, OPT_ftree_ch
, NULL
, 1 },
576 { OPT_LEVELS_1_PLUS
, OPT_ftree_coalesce_vars
, NULL
, 1 },
577 { OPT_LEVELS_1_PLUS
, OPT_ftree_copy_prop
, NULL
, 1 },
578 { OPT_LEVELS_1_PLUS
, OPT_ftree_dce
, NULL
, 1 },
579 { OPT_LEVELS_1_PLUS
, OPT_ftree_dominator_opts
, NULL
, 1 },
580 { OPT_LEVELS_1_PLUS
, OPT_ftree_fre
, NULL
, 1 },
581 { OPT_LEVELS_1_PLUS
, OPT_ftree_sink
, NULL
, 1 },
582 { OPT_LEVELS_1_PLUS
, OPT_ftree_slsr
, NULL
, 1 },
583 { OPT_LEVELS_1_PLUS
, OPT_ftree_ter
, NULL
, 1 },
584 { OPT_LEVELS_1_PLUS
, OPT_fvar_tracking
, NULL
, 1 },
586 /* -O1 (and not -Og) optimizations. */
587 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fbranch_count_reg
, NULL
, 1 },
589 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fdelayed_branch
, NULL
, 1 },
591 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fdse
, NULL
, 1 },
592 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion
, NULL
, 1 },
593 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion2
, NULL
, 1 },
594 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_finline_functions_called_once
, NULL
, 1 },
595 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_invariants
, NULL
, 1 },
596 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_stores
, NULL
, 1 },
597 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fssa_phiopt
, NULL
, 1 },
598 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fipa_modref
, NULL
, 1 },
599 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_bit_ccp
, NULL
, 1 },
600 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_dse
, NULL
, 1 },
601 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_pta
, NULL
, 1 },
602 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_sra
, NULL
, 1 },
604 /* -O2 and -Os optimizations. */
605 { OPT_LEVELS_2_PLUS
, OPT_fcaller_saves
, NULL
, 1 },
606 { OPT_LEVELS_2_PLUS
, OPT_fcode_hoisting
, NULL
, 1 },
607 { OPT_LEVELS_2_PLUS
, OPT_fcrossjumping
, NULL
, 1 },
608 { OPT_LEVELS_2_PLUS
, OPT_fcse_follow_jumps
, NULL
, 1 },
609 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize
, NULL
, 1 },
610 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize_speculatively
, NULL
, 1 },
611 { OPT_LEVELS_2_PLUS
, OPT_fexpensive_optimizations
, NULL
, 1 },
612 { OPT_LEVELS_2_PLUS
, OPT_fgcse
, NULL
, 1 },
613 { OPT_LEVELS_2_PLUS
, OPT_fhoist_adjacent_loads
, NULL
, 1 },
614 { OPT_LEVELS_2_PLUS
, OPT_findirect_inlining
, NULL
, 1 },
615 { OPT_LEVELS_2_PLUS
, OPT_finline_small_functions
, NULL
, 1 },
616 { OPT_LEVELS_2_PLUS
, OPT_fipa_bit_cp
, NULL
, 1 },
617 { OPT_LEVELS_2_PLUS
, OPT_fipa_cp
, NULL
, 1 },
618 { OPT_LEVELS_2_PLUS
, OPT_fipa_icf
, NULL
, 1 },
619 { OPT_LEVELS_2_PLUS
, OPT_fipa_ra
, NULL
, 1 },
620 { OPT_LEVELS_2_PLUS
, OPT_fipa_sra
, NULL
, 1 },
621 { OPT_LEVELS_2_PLUS
, OPT_fipa_vrp
, NULL
, 1 },
622 { OPT_LEVELS_2_PLUS
, OPT_fisolate_erroneous_paths_dereference
, NULL
, 1 },
623 { OPT_LEVELS_2_PLUS
, OPT_flra_remat
, NULL
, 1 },
624 { OPT_LEVELS_2_PLUS
, OPT_foptimize_sibling_calls
, NULL
, 1 },
625 { OPT_LEVELS_2_PLUS
, OPT_fpartial_inlining
, NULL
, 1 },
626 { OPT_LEVELS_2_PLUS
, OPT_fpeephole2
, NULL
, 1 },
627 { OPT_LEVELS_2_PLUS
, OPT_freorder_functions
, NULL
, 1 },
628 { OPT_LEVELS_2_PLUS
, OPT_frerun_cse_after_loop
, NULL
, 1 },
629 #ifdef INSN_SCHEDULING
630 { OPT_LEVELS_2_PLUS
, OPT_fschedule_insns2
, NULL
, 1 },
632 { OPT_LEVELS_2_PLUS
, OPT_fstrict_aliasing
, NULL
, 1 },
633 { OPT_LEVELS_2_PLUS
, OPT_fstore_merging
, NULL
, 1 },
634 { OPT_LEVELS_2_PLUS
, OPT_ftree_pre
, NULL
, 1 },
635 { OPT_LEVELS_2_PLUS
, OPT_ftree_switch_conversion
, NULL
, 1 },
636 { OPT_LEVELS_2_PLUS
, OPT_ftree_tail_merge
, NULL
, 1 },
637 { OPT_LEVELS_2_PLUS
, OPT_ftree_vrp
, NULL
, 1 },
638 { OPT_LEVELS_2_PLUS
, OPT_fvect_cost_model_
, NULL
,
639 VECT_COST_MODEL_VERY_CHEAP
},
640 { OPT_LEVELS_2_PLUS
, OPT_finline_functions
, NULL
, 1 },
641 { OPT_LEVELS_2_PLUS
, OPT_ftree_loop_distribute_patterns
, NULL
, 1 },
643 /* -O2 and above optimizations, but not -Os or -Og. */
644 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_functions
, NULL
, 1 },
645 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_jumps
, NULL
, 1 },
646 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_labels
, NULL
, 1 },
647 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_loops
, NULL
, 1 },
648 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_foptimize_strlen
, NULL
, 1 },
649 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_freorder_blocks_algorithm_
, NULL
,
650 REORDER_BLOCKS_ALGORITHM_STC
},
651 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_ftree_loop_vectorize
, NULL
, 1 },
652 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_ftree_slp_vectorize
, NULL
, 1 },
653 #ifdef INSN_SCHEDULING
654 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
655 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_fschedule_insns
, NULL
, 1 },
658 /* -O3 and -Os optimizations. */
660 /* -O3 optimizations. */
661 { OPT_LEVELS_3_PLUS
, OPT_fgcse_after_reload
, NULL
, 1 },
662 { OPT_LEVELS_3_PLUS
, OPT_fipa_cp_clone
, NULL
, 1 },
663 { OPT_LEVELS_3_PLUS
, OPT_floop_interchange
, NULL
, 1 },
664 { OPT_LEVELS_3_PLUS
, OPT_floop_unroll_and_jam
, NULL
, 1 },
665 { OPT_LEVELS_3_PLUS
, OPT_fpeel_loops
, NULL
, 1 },
666 { OPT_LEVELS_3_PLUS
, OPT_fpredictive_commoning
, NULL
, 1 },
667 { OPT_LEVELS_3_PLUS
, OPT_fsplit_loops
, NULL
, 1 },
668 { OPT_LEVELS_3_PLUS
, OPT_fsplit_paths
, NULL
, 1 },
669 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribution
, NULL
, 1 },
670 { OPT_LEVELS_3_PLUS
, OPT_ftree_partial_pre
, NULL
, 1 },
671 { OPT_LEVELS_3_PLUS
, OPT_funswitch_loops
, NULL
, 1 },
672 { OPT_LEVELS_3_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_DYNAMIC
},
673 { OPT_LEVELS_3_PLUS
, OPT_fversion_loops_for_strides
, NULL
, 1 },
675 /* -O3 parameters. */
676 { OPT_LEVELS_3_PLUS
, OPT__param_max_inline_insns_auto_
, NULL
, 30 },
677 { OPT_LEVELS_3_PLUS
, OPT__param_early_inlining_insns_
, NULL
, 14 },
678 { OPT_LEVELS_3_PLUS
, OPT__param_inline_heuristics_hint_percent_
, NULL
, 600 },
679 { OPT_LEVELS_3_PLUS
, OPT__param_inline_min_speedup_
, NULL
, 15 },
680 { OPT_LEVELS_3_PLUS
, OPT__param_max_inline_insns_single_
, NULL
, 200 },
682 /* -Ofast adds optimizations to -O3. */
683 { OPT_LEVELS_FAST
, OPT_ffast_math
, NULL
, 1 },
684 { OPT_LEVELS_FAST
, OPT_fallow_store_data_races
, NULL
, 1 },
686 { OPT_LEVELS_NONE
, 0, NULL
, 0 }
689 /* Default the options in OPTS and OPTS_SET based on the optimization
690 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
692 default_options_optimization (struct gcc_options
*opts
,
693 struct gcc_options
*opts_set
,
694 struct cl_decoded_option
*decoded_options
,
695 unsigned int decoded_options_count
,
697 unsigned int lang_mask
,
698 const struct cl_option_handlers
*handlers
,
699 diagnostic_context
*dc
)
703 bool openacc_mode
= false;
705 /* Scan to see what optimization level has been specified. That will
706 determine the default value of many flags. */
707 for (i
= 1; i
< decoded_options_count
; i
++)
709 struct cl_decoded_option
*opt
= &decoded_options
[i
];
710 switch (opt
->opt_index
)
713 if (*opt
->arg
== '\0')
715 opts
->x_optimize
= 1;
716 opts
->x_optimize_size
= 0;
717 opts
->x_optimize_fast
= 0;
718 opts
->x_optimize_debug
= 0;
722 const int optimize_val
= integral_argument (opt
->arg
);
723 if (optimize_val
== -1)
724 error_at (loc
, "argument to %<-O%> should be a non-negative "
725 "integer, %<g%>, %<s%> or %<fast%>");
728 opts
->x_optimize
= optimize_val
;
729 if ((unsigned int) opts
->x_optimize
> 255)
730 opts
->x_optimize
= 255;
731 opts
->x_optimize_size
= 0;
732 opts
->x_optimize_fast
= 0;
733 opts
->x_optimize_debug
= 0;
739 opts
->x_optimize_size
= 1;
741 /* Optimizing for size forces optimize to be 2. */
742 opts
->x_optimize
= 2;
743 opts
->x_optimize_fast
= 0;
744 opts
->x_optimize_debug
= 0;
748 /* -Ofast only adds flags to -O3. */
749 opts
->x_optimize_size
= 0;
750 opts
->x_optimize
= 3;
751 opts
->x_optimize_fast
= 1;
752 opts
->x_optimize_debug
= 0;
756 /* -Og selects optimization level 1. */
757 opts
->x_optimize_size
= 0;
758 opts
->x_optimize
= 1;
759 opts
->x_optimize_fast
= 0;
760 opts
->x_optimize_debug
= 1;
769 /* Ignore other options in this prescan. */
774 maybe_default_options (opts
, opts_set
, default_options_table
,
775 opts
->x_optimize
, opts
->x_optimize_size
,
776 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
777 lang_mask
, handlers
, loc
, dc
);
779 /* -O2 param settings. */
780 opt2
= (opts
->x_optimize
>= 2);
783 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_pta
, true);
785 /* Track fields in field-sensitive alias analysis. */
787 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_fields_for_field_sensitive
,
790 if (opts
->x_optimize_size
)
791 /* We want to crossjump as much as possible. */
792 SET_OPTION_IF_UNSET (opts
, opts_set
, param_min_crossjump_insns
, 1);
794 /* Restrict the amount of work combine does at -Og while retaining
795 most of its useful transforms. */
796 if (opts
->x_optimize_debug
)
797 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_combine_insns
, 2);
799 /* Allow default optimizations to be specified on a per-machine basis. */
800 maybe_default_options (opts
, opts_set
,
801 targetm_common
.option_optimization_table
,
802 opts
->x_optimize
, opts
->x_optimize_size
,
803 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
804 lang_mask
, handlers
, loc
, dc
);
807 /* Control IPA optimizations based on different live patching LEVEL. */
809 control_options_for_live_patching (struct gcc_options
*opts
,
810 struct gcc_options
*opts_set
,
811 enum live_patching_level level
,
814 gcc_assert (level
> LIVE_PATCHING_NONE
);
818 case LIVE_PATCHING_INLINE_ONLY_STATIC
:
819 #define LIVE_PATCHING_OPTION "-flive-patching=inline-only-static"
820 if (opts_set
->x_flag_ipa_cp_clone
&& opts
->x_flag_ipa_cp_clone
)
821 error_at (loc
, "%qs is incompatible with %qs",
822 "-fipa-cp-clone", LIVE_PATCHING_OPTION
);
824 opts
->x_flag_ipa_cp_clone
= 0;
826 if (opts_set
->x_flag_ipa_sra
&& opts
->x_flag_ipa_sra
)
827 error_at (loc
, "%qs is incompatible with %qs",
828 "-fipa-sra", LIVE_PATCHING_OPTION
);
830 opts
->x_flag_ipa_sra
= 0;
832 if (opts_set
->x_flag_partial_inlining
&& opts
->x_flag_partial_inlining
)
833 error_at (loc
, "%qs is incompatible with %qs",
834 "-fpartial-inlining", LIVE_PATCHING_OPTION
);
836 opts
->x_flag_partial_inlining
= 0;
838 if (opts_set
->x_flag_ipa_cp
&& opts
->x_flag_ipa_cp
)
839 error_at (loc
, "%qs is incompatible with %qs",
840 "-fipa-cp", LIVE_PATCHING_OPTION
);
842 opts
->x_flag_ipa_cp
= 0;
845 case LIVE_PATCHING_INLINE_CLONE
:
846 #undef LIVE_PATCHING_OPTION
847 #define LIVE_PATCHING_OPTION "-flive-patching=inline-only-static|inline-clone"
848 /* live patching should disable whole-program optimization. */
849 if (opts_set
->x_flag_whole_program
&& opts
->x_flag_whole_program
)
850 error_at (loc
, "%qs is incompatible with %qs",
851 "-fwhole-program", LIVE_PATCHING_OPTION
);
853 opts
->x_flag_whole_program
= 0;
855 /* visibility change should be excluded by !flag_whole_program
856 && !in_lto_p && !flag_ipa_cp_clone && !flag_ipa_sra
857 && !flag_partial_inlining. */
859 if (opts_set
->x_flag_ipa_pta
&& opts
->x_flag_ipa_pta
)
860 error_at (loc
, "%qs is incompatible with %qs",
861 "-fipa-pta", LIVE_PATCHING_OPTION
);
863 opts
->x_flag_ipa_pta
= 0;
865 if (opts_set
->x_flag_ipa_reference
&& opts
->x_flag_ipa_reference
)
866 error_at (loc
, "%qs is incompatible with %qs",
867 "-fipa-reference", LIVE_PATCHING_OPTION
);
869 opts
->x_flag_ipa_reference
= 0;
871 if (opts_set
->x_flag_ipa_ra
&& opts
->x_flag_ipa_ra
)
872 error_at (loc
, "%qs is incompatible with %qs",
873 "-fipa-ra", LIVE_PATCHING_OPTION
);
875 opts
->x_flag_ipa_ra
= 0;
877 if (opts_set
->x_flag_ipa_icf
&& opts
->x_flag_ipa_icf
)
878 error_at (loc
, "%qs is incompatible with %qs",
879 "-fipa-icf", LIVE_PATCHING_OPTION
);
881 opts
->x_flag_ipa_icf
= 0;
883 if (opts_set
->x_flag_ipa_icf_functions
&& opts
->x_flag_ipa_icf_functions
)
884 error_at (loc
, "%qs is incompatible with %qs",
885 "-fipa-icf-functions", LIVE_PATCHING_OPTION
);
887 opts
->x_flag_ipa_icf_functions
= 0;
889 if (opts_set
->x_flag_ipa_icf_variables
&& opts
->x_flag_ipa_icf_variables
)
890 error_at (loc
, "%qs is incompatible with %qs",
891 "-fipa-icf-variables", LIVE_PATCHING_OPTION
);
893 opts
->x_flag_ipa_icf_variables
= 0;
895 if (opts_set
->x_flag_ipa_bit_cp
&& opts
->x_flag_ipa_bit_cp
)
896 error_at (loc
, "%qs is incompatible with %qs",
897 "-fipa-bit-cp", LIVE_PATCHING_OPTION
);
899 opts
->x_flag_ipa_bit_cp
= 0;
901 if (opts_set
->x_flag_ipa_vrp
&& opts
->x_flag_ipa_vrp
)
902 error_at (loc
, "%qs is incompatible with %qs",
903 "-fipa-vrp", LIVE_PATCHING_OPTION
);
905 opts
->x_flag_ipa_vrp
= 0;
907 if (opts_set
->x_flag_ipa_pure_const
&& opts
->x_flag_ipa_pure_const
)
908 error_at (loc
, "%qs is incompatible with %qs",
909 "-fipa-pure-const", LIVE_PATCHING_OPTION
);
911 opts
->x_flag_ipa_pure_const
= 0;
913 if (opts_set
->x_flag_ipa_modref
&& opts
->x_flag_ipa_modref
)
915 "%<-fipa-modref%> is incompatible with %qs",
916 LIVE_PATCHING_OPTION
);
918 opts
->x_flag_ipa_modref
= 0;
920 /* FIXME: disable unreachable code removal. */
922 /* discovery of functions/variables with no address taken. */
923 if (opts_set
->x_flag_ipa_reference_addressable
924 && opts
->x_flag_ipa_reference_addressable
)
925 error_at (loc
, "%qs is incompatible with %qs",
926 "-fipa-reference-addressable", LIVE_PATCHING_OPTION
);
928 opts
->x_flag_ipa_reference_addressable
= 0;
930 /* ipa stack alignment propagation. */
931 if (opts_set
->x_flag_ipa_stack_alignment
932 && opts
->x_flag_ipa_stack_alignment
)
933 error_at (loc
, "%qs is incompatible with %qs",
934 "-fipa-stack-alignment", LIVE_PATCHING_OPTION
);
936 opts
->x_flag_ipa_stack_alignment
= 0;
942 #undef LIVE_PATCHING_OPTION
945 /* --help option argument if set. */
946 vec
<const char *> help_option_arguments
;
948 /* Return the string name describing a sanitizer argument which has been
949 provided on the command line and has set this particular flag. */
951 find_sanitizer_argument (struct gcc_options
*opts
, unsigned int flags
)
953 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
955 /* Need to find the sanitizer_opts element which:
956 a) Could have set the flags requested.
957 b) Has been set on the command line.
959 Can have (a) without (b) if the flag requested is e.g.
960 SANITIZE_ADDRESS, since both -fsanitize=address and
961 -fsanitize=kernel-address set this flag.
963 Can have (b) without (a) by requesting more than one sanitizer on the
965 if ((sanitizer_opts
[i
].flag
& opts
->x_flag_sanitize
)
966 != sanitizer_opts
[i
].flag
)
968 if ((sanitizer_opts
[i
].flag
& flags
) != flags
)
970 return sanitizer_opts
[i
].name
;
976 /* Report an error to the user about sanitizer options they have requested
977 which have set conflicting flags.
979 LEFT and RIGHT indicate sanitizer flags which conflict with each other, this
980 function reports an error if both have been set in OPTS->x_flag_sanitize and
981 ensures the error identifies the requested command line options that have
984 report_conflicting_sanitizer_options (struct gcc_options
*opts
, location_t loc
,
985 unsigned int left
, unsigned int right
)
987 unsigned int left_seen
= (opts
->x_flag_sanitize
& left
);
988 unsigned int right_seen
= (opts
->x_flag_sanitize
& right
);
989 if (left_seen
&& right_seen
)
991 const char* left_arg
= find_sanitizer_argument (opts
, left_seen
);
992 const char* right_arg
= find_sanitizer_argument (opts
, right_seen
);
993 gcc_assert (left_arg
&& right_arg
);
995 "%<-fsanitize=%s%> is incompatible with %<-fsanitize=%s%>",
996 left_arg
, right_arg
);
1000 /* After all options at LOC have been read into OPTS and OPTS_SET,
1001 finalize settings of those options and diagnose incompatible
1004 finish_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
1007 enum unwind_info_type ui_except
;
1009 if (opts
->x_dump_base_name
1010 && ! opts
->x_dump_base_name_prefixed
)
1012 const char *sep
= opts
->x_dump_base_name
;
1015 if (IS_DIR_SEPARATOR (*sep
))
1019 /* If dump_base_path contains subdirectories, don't prepend
1021 else if (opts
->x_dump_dir_name
)
1022 /* We have a DUMP_DIR_NAME, prepend that. */
1023 opts
->x_dump_base_name
= opts_concat (opts
->x_dump_dir_name
,
1024 opts
->x_dump_base_name
, NULL
);
1026 /* It is definitely prefixed now. */
1027 opts
->x_dump_base_name_prefixed
= true;
1030 /* Handle related options for unit-at-a-time, toplevel-reorder, and
1032 if (!opts
->x_flag_unit_at_a_time
)
1034 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
1035 error_at (loc
, "section anchors must be disabled when unit-at-a-time "
1037 opts
->x_flag_section_anchors
= 0;
1038 if (opts
->x_flag_toplevel_reorder
== 1)
1039 error_at (loc
, "toplevel reorder must be disabled when unit-at-a-time "
1041 opts
->x_flag_toplevel_reorder
= 0;
1044 /* -fself-test depends on the state of the compiler prior to
1045 compiling anything. Ideally it should be run on an empty source
1046 file. However, in case we get run with actual source, assume
1047 -fsyntax-only which will inhibit any compiler initialization
1048 which may confuse the self tests. */
1049 if (opts
->x_flag_self_test
)
1050 opts
->x_flag_syntax_only
= 1;
1052 if (opts
->x_flag_tm
&& opts
->x_flag_non_call_exceptions
)
1053 sorry ("transactional memory is not supported with non-call exceptions");
1055 /* Unless the user has asked for section anchors, we disable toplevel
1056 reordering at -O0 to disable transformations that might be surprising
1057 to end users and to get -fno-toplevel-reorder tested. */
1058 if (!opts
->x_optimize
1059 && opts
->x_flag_toplevel_reorder
== 2
1060 && !(opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
))
1062 opts
->x_flag_toplevel_reorder
= 0;
1063 opts
->x_flag_section_anchors
= 0;
1065 if (!opts
->x_flag_toplevel_reorder
)
1067 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
1068 error_at (loc
, "section anchors must be disabled when toplevel reorder"
1070 opts
->x_flag_section_anchors
= 0;
1073 if (!opts
->x_flag_opts_finished
)
1075 /* We initialize opts->x_flag_pie to -1 so that targets can set a
1077 if (opts
->x_flag_pie
== -1)
1079 /* We initialize opts->x_flag_pic to -1 so that we can tell if
1080 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
1081 if (opts
->x_flag_pic
== -1)
1082 opts
->x_flag_pie
= DEFAULT_FLAG_PIE
;
1084 opts
->x_flag_pie
= 0;
1086 /* If -fPIE or -fpie is used, turn on PIC. */
1087 if (opts
->x_flag_pie
)
1088 opts
->x_flag_pic
= opts
->x_flag_pie
;
1089 else if (opts
->x_flag_pic
== -1)
1090 opts
->x_flag_pic
= 0;
1091 if (opts
->x_flag_pic
&& !opts
->x_flag_pie
)
1092 opts
->x_flag_shlib
= 1;
1093 opts
->x_flag_opts_finished
= true;
1096 /* We initialize opts->x_flag_stack_protect to -1 so that targets
1097 can set a default value. */
1098 if (opts
->x_flag_stack_protect
== -1)
1099 opts
->x_flag_stack_protect
= DEFAULT_FLAG_SSP
;
1101 if (opts
->x_optimize
== 0)
1103 /* Inlining does not work if not optimizing,
1104 so force it not to be done. */
1105 opts
->x_warn_inline
= 0;
1106 opts
->x_flag_no_inline
= 1;
1109 /* The optimization to partition hot and cold basic blocks into separate
1110 sections of the .o and executable files does not work (currently)
1111 with exception handling. This is because there is no support for
1112 generating unwind info. If opts->x_flag_exceptions is turned on
1113 we need to turn off the partitioning optimization. */
1115 ui_except
= targetm_common
.except_unwind_info (opts
);
1117 if (opts
->x_flag_exceptions
1118 && opts
->x_flag_reorder_blocks_and_partition
1119 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1121 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1123 "%<-freorder-blocks-and-partition%> does not work "
1124 "with exceptions on this architecture");
1125 opts
->x_flag_reorder_blocks_and_partition
= 0;
1126 opts
->x_flag_reorder_blocks
= 1;
1129 /* If user requested unwind info, then turn off the partitioning
1132 if (opts
->x_flag_unwind_tables
1133 && !targetm_common
.unwind_tables_default
1134 && opts
->x_flag_reorder_blocks_and_partition
1135 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1137 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1139 "%<-freorder-blocks-and-partition%> does not support "
1140 "unwind info on this architecture");
1141 opts
->x_flag_reorder_blocks_and_partition
= 0;
1142 opts
->x_flag_reorder_blocks
= 1;
1145 /* If the target requested unwind info, then turn off the partitioning
1146 optimization with a different message. Likewise, if the target does not
1147 support named sections. */
1149 if (opts
->x_flag_reorder_blocks_and_partition
1150 && (!targetm_common
.have_named_sections
1151 || (opts
->x_flag_unwind_tables
1152 && targetm_common
.unwind_tables_default
1153 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
1155 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1157 "%<-freorder-blocks-and-partition%> does not work "
1158 "on this architecture");
1159 opts
->x_flag_reorder_blocks_and_partition
= 0;
1160 opts
->x_flag_reorder_blocks
= 1;
1164 /* Pipelining of outer loops is only possible when general pipelining
1165 capabilities are requested. */
1166 if (!opts
->x_flag_sel_sched_pipelining
)
1167 opts
->x_flag_sel_sched_pipelining_outer_loops
= 0;
1169 if (opts
->x_flag_conserve_stack
)
1171 SET_OPTION_IF_UNSET (opts
, opts_set
, param_large_stack_frame
, 100);
1172 SET_OPTION_IF_UNSET (opts
, opts_set
, param_stack_frame_growth
, 40);
1175 if (opts
->x_flag_lto
)
1178 opts
->x_flag_generate_lto
= 1;
1180 /* When generating IL, do not operate in whole-program mode.
1181 Otherwise, symbols will be privatized too early, causing link
1183 opts
->x_flag_whole_program
= 0;
1185 error_at (loc
, "LTO support has not been enabled in this configuration");
1187 if (!opts
->x_flag_fat_lto_objects
1188 && (!HAVE_LTO_PLUGIN
1189 || (opts_set
->x_flag_use_linker_plugin
1190 && !opts
->x_flag_use_linker_plugin
)))
1192 if (opts_set
->x_flag_fat_lto_objects
)
1193 error_at (loc
, "%<-fno-fat-lto-objects%> are supported only with "
1195 opts
->x_flag_fat_lto_objects
= 1;
1198 /* -gsplit-dwarf isn't compatible with LTO, see PR88389. */
1199 if (opts
->x_dwarf_split_debug_info
)
1201 inform (loc
, "%<-gsplit-dwarf%> is not supported with LTO,"
1203 opts
->x_dwarf_split_debug_info
= 0;
1207 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
1208 default value if they choose based on other options. */
1209 if (opts
->x_flag_split_stack
== -1)
1210 opts
->x_flag_split_stack
= 0;
1211 else if (opts
->x_flag_split_stack
)
1213 if (!targetm_common
.supports_split_stack (true, opts
))
1215 error_at (loc
, "%<-fsplit-stack%> is not supported by "
1216 "this compiler configuration");
1217 opts
->x_flag_split_stack
= 0;
1221 /* If stack splitting is turned on, and the user did not explicitly
1222 request function partitioning, turn off partitioning, as it
1223 confuses the linker when trying to handle partitioned split-stack
1224 code that calls a non-split-stack functions. But if partitioning
1225 was turned on explicitly just hope for the best. */
1226 if (opts
->x_flag_split_stack
1227 && opts
->x_flag_reorder_blocks_and_partition
)
1228 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_reorder_blocks_and_partition
, 0);
1230 if (opts
->x_flag_reorder_blocks_and_partition
)
1231 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_reorder_functions
, 1);
1233 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
1234 if (opts
->x_dwarf_split_debug_info
)
1235 opts
->x_debug_generate_pub_sections
= 2;
1237 if ((opts
->x_flag_sanitize
1238 & (SANITIZE_USER_ADDRESS
| SANITIZE_KERNEL_ADDRESS
)) == 0)
1240 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_COMPARE
)
1242 "%<-fsanitize=pointer-compare%> must be combined with "
1243 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1244 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_SUBTRACT
)
1246 "%<-fsanitize=pointer-subtract%> must be combined with "
1247 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1250 /* Address sanitizers conflict with the thread sanitizer. */
1251 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_THREAD
,
1252 SANITIZE_ADDRESS
| SANITIZE_HWADDRESS
);
1253 /* The leak sanitizer conflicts with the thread sanitizer. */
1254 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_LEAK
,
1257 /* No combination of HWASAN and ASAN work together. */
1258 report_conflicting_sanitizer_options (opts
, loc
,
1259 SANITIZE_HWADDRESS
, SANITIZE_ADDRESS
);
1261 /* The userspace and kernel address sanitizers conflict with each other. */
1262 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_USER_HWADDRESS
,
1263 SANITIZE_KERNEL_HWADDRESS
);
1264 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_USER_ADDRESS
,
1265 SANITIZE_KERNEL_ADDRESS
);
1267 /* Check error recovery for -fsanitize-recover option. */
1268 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1269 if ((opts
->x_flag_sanitize_recover
& sanitizer_opts
[i
].flag
)
1270 && !sanitizer_opts
[i
].can_recover
)
1271 error_at (loc
, "%<-fsanitize-recover=%s%> is not supported",
1272 sanitizer_opts
[i
].name
);
1274 /* When instrumenting the pointers, we don't want to remove
1275 the null pointer checks. */
1276 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
1277 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
1278 opts
->x_flag_delete_null_pointer_checks
= 0;
1280 /* Aggressive compiler optimizations may cause false negatives. */
1281 if (opts
->x_flag_sanitize
& ~(SANITIZE_LEAK
| SANITIZE_UNREACHABLE
))
1282 opts
->x_flag_aggressive_loop_optimizations
= 0;
1284 /* Enable -fsanitize-address-use-after-scope if either address sanitizer is
1286 if (opts
->x_flag_sanitize
1287 & (SANITIZE_USER_ADDRESS
| SANITIZE_USER_HWADDRESS
))
1288 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_sanitize_address_use_after_scope
,
1291 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1293 if (opts
->x_flag_sanitize_address_use_after_scope
)
1295 if (opts
->x_flag_stack_reuse
!= SR_NONE
1296 && opts_set
->x_flag_stack_reuse
!= SR_NONE
)
1298 "%<-fsanitize-address-use-after-scope%> requires "
1299 "%<-fstack-reuse=none%> option");
1301 opts
->x_flag_stack_reuse
= SR_NONE
;
1304 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
) && opts
->x_flag_tm
)
1305 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1307 if ((opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) && opts
->x_flag_tm
)
1308 sorry ("transactional memory is not supported with "
1309 "%<-fsanitize=kernel-address%>");
1311 /* Currently live patching is not support for LTO. */
1312 if (opts
->x_flag_live_patching
&& opts
->x_flag_lto
)
1313 sorry ("live patching is not supported with LTO");
1315 /* Currently vtable verification is not supported for LTO */
1316 if (opts
->x_flag_vtable_verify
&& opts
->x_flag_lto
)
1317 sorry ("vtable verification is not supported with LTO");
1319 /* Control IPA optimizations based on different -flive-patching level. */
1320 if (opts
->x_flag_live_patching
)
1321 control_options_for_live_patching (opts
, opts_set
,
1322 opts
->x_flag_live_patching
,
1325 /* Allow cunroll to grow size accordingly. */
1326 if (!opts_set
->x_flag_cunroll_grow_size
)
1327 opts
->x_flag_cunroll_grow_size
1328 = (opts
->x_flag_unroll_loops
1329 || opts
->x_flag_peel_loops
1330 || opts
->x_optimize
>= 3);
1332 /* With -fcx-limited-range, we do cheap and quick complex arithmetic. */
1333 if (opts
->x_flag_cx_limited_range
)
1334 opts
->x_flag_complex_method
= 0;
1335 else if (opts_set
->x_flag_cx_limited_range
)
1336 opts
->x_flag_complex_method
= opts
->x_flag_default_complex_method
;
1338 /* With -fcx-fortran-rules, we do something in-between cheap and C99. */
1339 if (opts
->x_flag_cx_fortran_rules
)
1340 opts
->x_flag_complex_method
= 1;
1341 else if (opts_set
->x_flag_cx_fortran_rules
)
1342 opts
->x_flag_complex_method
= opts
->x_flag_default_complex_method
;
1344 /* Use -fvect-cost-model=cheap instead of -fvect-cost-mode=very-cheap
1345 by default with explicit -ftree-{loop,slp}-vectorize. */
1346 if (opts
->x_optimize
== 2
1347 && (opts_set
->x_flag_tree_loop_vectorize
1348 || opts_set
->x_flag_tree_vectorize
))
1349 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_vect_cost_model
,
1350 VECT_COST_MODEL_CHEAP
);
1352 /* One could use EnabledBy, but it would lead to a circular dependency. */
1353 if (!OPTION_SET_P (flag_var_tracking_uninit
))
1354 flag_var_tracking_uninit
= flag_var_tracking
;
1356 if (!OPTION_SET_P (flag_var_tracking_assignments
))
1357 flag_var_tracking_assignments
1358 = (flag_var_tracking
1359 && !(flag_selective_scheduling
|| flag_selective_scheduling2
));
1361 if (flag_var_tracking_assignments_toggle
)
1362 flag_var_tracking_assignments
= !flag_var_tracking_assignments
;
1364 if (flag_var_tracking_assignments
&& !flag_var_tracking
)
1365 flag_var_tracking
= flag_var_tracking_assignments
= -1;
1367 if (flag_var_tracking_assignments
1368 && (flag_selective_scheduling
|| flag_selective_scheduling2
))
1370 "var-tracking-assignments changes selective scheduling");
1372 if (flag_syntax_only
)
1374 write_symbols
= NO_DEBUG
;
1380 if (debug_info_level
== DINFO_LEVEL_NONE
)
1382 debug_info_level
= DINFO_LEVEL_NORMAL
;
1384 if (write_symbols
== NO_DEBUG
)
1385 write_symbols
= PREFERRED_DEBUGGING_TYPE
;
1388 debug_info_level
= DINFO_LEVEL_NONE
;
1391 if (!OPTION_SET_P (debug_nonbind_markers_p
))
1392 debug_nonbind_markers_p
1394 && debug_info_level
>= DINFO_LEVEL_NORMAL
1395 && dwarf_debuginfo_p ()
1396 && !(flag_selective_scheduling
|| flag_selective_scheduling2
));
1399 #define LEFT_COLUMN 27
1401 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1402 followed by word-wrapped HELP in a second column. */
1404 wrap_help (const char *help
,
1406 unsigned int item_width
,
1407 unsigned int columns
)
1409 unsigned int col_width
= LEFT_COLUMN
;
1410 unsigned int remaining
, room
, len
;
1412 remaining
= strlen (help
);
1416 room
= columns
- 3 - MAX (col_width
, item_width
);
1425 for (i
= 0; help
[i
]; i
++)
1427 if (i
>= room
&& len
!= remaining
)
1431 else if ((help
[i
] == '-' || help
[i
] == '/')
1432 && help
[i
+ 1] != ' '
1433 && i
> 0 && ISALPHA (help
[i
- 1]))
1438 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1440 while (help
[len
] == ' ')
1448 /* Data structure used to print list of valid option values. */
1450 class option_help_tuple
1453 option_help_tuple (int code
, vec
<const char *> values
):
1454 m_code (code
), m_values (values
)
1457 /* Code of an option. */
1460 /* List of possible values. */
1461 vec
<const char *> m_values
;
1464 /* Print help for a specific front-end, etc. */
1466 print_filtered_help (unsigned int include_flags
,
1467 unsigned int exclude_flags
,
1468 unsigned int any_flags
,
1469 unsigned int columns
,
1470 struct gcc_options
*opts
,
1471 unsigned int lang_mask
)
1476 bool displayed
= false;
1479 if (!opts
->x_help_printed
)
1480 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1482 if (!opts
->x_help_enum_printed
)
1483 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1485 auto_vec
<option_help_tuple
> help_tuples
;
1487 for (i
= 0; i
< cl_options_count
; i
++)
1489 const struct cl_option
*option
= cl_options
+ i
;
1494 if (include_flags
== 0
1495 || ((option
->flags
& include_flags
) != include_flags
))
1497 if ((option
->flags
& any_flags
) == 0)
1501 /* Skip unwanted switches. */
1502 if ((option
->flags
& exclude_flags
) != 0)
1505 /* The driver currently prints its own help text. */
1506 if ((option
->flags
& CL_DRIVER
) != 0
1507 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1508 | CL_COMMON
| CL_TARGET
)) == 0)
1511 /* If an option contains a language specification,
1512 exclude it from common unless all languages are present. */
1513 if ((include_flags
& CL_COMMON
)
1514 && !(option
->flags
& CL_DRIVER
)
1515 && (option
->flags
& CL_LANG_ALL
)
1516 && (option
->flags
& CL_LANG_ALL
) != CL_LANG_ALL
)
1520 /* Skip switches that have already been printed. */
1521 if (opts
->x_help_printed
[i
])
1524 opts
->x_help_printed
[i
] = true;
1526 help
= option
->help
;
1529 if (exclude_flags
& CL_UNDOCUMENTED
)
1532 help
= undocumented_msg
;
1535 /* Get the translation. */
1538 if (option
->alias_target
< N_OPTS
1539 && cl_options
[option
->alias_target
].help
)
1541 const struct cl_option
*target
= cl_options
+ option
->alias_target
;
1542 if (option
->help
== NULL
)
1544 /* The option is undocumented but is an alias for an option that
1545 is documented. If the option has alias arguments, then its
1546 purpose is to provide certain arguments to the other option, so
1547 inform the reader of this. Otherwise, point the reader to the
1548 other option in preference to the former. */
1550 if (option
->alias_arg
)
1552 if (option
->neg_alias_arg
)
1553 snprintf (new_help
, sizeof new_help
,
1554 _("Same as %s%s (or, in negated form, %s%s)."),
1555 target
->opt_text
, option
->alias_arg
,
1556 target
->opt_text
, option
->neg_alias_arg
);
1558 snprintf (new_help
, sizeof new_help
,
1560 target
->opt_text
, option
->alias_arg
);
1563 snprintf (new_help
, sizeof new_help
,
1569 /* For documented options with aliases, mention the aliased
1570 option's name for reference. */
1571 snprintf (new_help
, sizeof new_help
,
1572 _("%s Same as %s."),
1573 help
, cl_options
[option
->alias_target
].opt_text
);
1579 if (option
->warn_message
)
1581 /* Mention that the use of the option will trigger a warning. */
1582 if (help
== new_help
)
1583 snprintf (new_help
+ strlen (new_help
),
1584 sizeof new_help
- strlen (new_help
),
1585 " %s", _(use_diagnosed_msg
));
1587 snprintf (new_help
, sizeof new_help
,
1588 "%s %s", help
, _(use_diagnosed_msg
));
1593 /* Find the gap between the name of the
1594 option and its descriptive text. */
1595 tab
= strchr (help
, '\t');
1604 opt
= option
->opt_text
;
1608 /* With the -Q option enabled we change the descriptive text associated
1609 with an option to be an indication of its current setting. */
1610 if (!opts
->x_quiet_flag
)
1612 void *flag_var
= option_flag_var (i
, opts
);
1614 if (len
< (LEFT_COLUMN
+ 2))
1615 strcpy (new_help
, "\t\t");
1617 strcpy (new_help
, "\t");
1619 /* Set to print whether the option is enabled or disabled,
1620 or, if it's an alias for another option, the name of
1621 the aliased option. */
1622 bool print_state
= false;
1624 if (flag_var
!= NULL
1625 && option
->var_type
!= CLVC_DEFER
)
1627 /* If OPTION is only available for a specific subset
1628 of languages other than this one, mention them. */
1629 bool avail_for_lang
= true;
1630 if (unsigned langset
= option
->flags
& CL_LANG_ALL
)
1632 if (!(langset
& lang_mask
))
1634 avail_for_lang
= false;
1635 strcat (new_help
, _("[available in "));
1636 for (unsigned i
= 0, n
= 0; (1U << i
) < CL_LANG_ALL
; ++i
)
1637 if (langset
& (1U << i
))
1640 strcat (new_help
, ", ");
1641 strcat (new_help
, lang_names
[i
]);
1643 strcat (new_help
, "]");
1646 if (!avail_for_lang
)
1647 ; /* Print nothing else if the option is not available
1648 in the current language. */
1649 else if (option
->flags
& CL_JOINED
)
1651 if (option
->var_type
== CLVC_STRING
)
1653 if (* (const char **) flag_var
!= NULL
)
1654 snprintf (new_help
+ strlen (new_help
),
1655 sizeof (new_help
) - strlen (new_help
),
1656 "%s", * (const char **) flag_var
);
1658 else if (option
->var_type
== CLVC_ENUM
)
1660 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1662 const char *arg
= NULL
;
1664 value
= e
->get (flag_var
);
1665 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1667 arg
= _("[default]");
1668 snprintf (new_help
+ strlen (new_help
),
1669 sizeof (new_help
) - strlen (new_help
),
1674 if (option
->cl_host_wide_int
)
1675 sprintf (new_help
+ strlen (new_help
),
1676 _("%llu bytes"), (unsigned long long)
1677 *(unsigned HOST_WIDE_INT
*) flag_var
);
1679 sprintf (new_help
+ strlen (new_help
),
1680 "%i", * (int *) flag_var
);
1687 /* When there is no argument, print the option state only
1688 if the option takes no argument. */
1689 print_state
= !(option
->flags
& CL_JOINED
);
1693 if (option
->alias_target
< N_OPTS
1694 && option
->alias_target
!= OPT_SPECIAL_warn_removed
1695 && option
->alias_target
!= OPT_SPECIAL_ignore
1696 && option
->alias_target
!= OPT_SPECIAL_input_file
1697 && option
->alias_target
!= OPT_SPECIAL_program_name
1698 && option
->alias_target
!= OPT_SPECIAL_unknown
)
1700 const struct cl_option
*target
1701 = &cl_options
[option
->alias_target
];
1702 sprintf (new_help
+ strlen (new_help
), "%s%s",
1704 option
->alias_arg
? option
->alias_arg
: "");
1706 else if (option
->alias_target
== OPT_SPECIAL_ignore
)
1707 strcat (new_help
, ("[ignored]"));
1710 /* Print the state for an on/off option. */
1711 int ena
= option_enabled (i
, lang_mask
, opts
);
1713 strcat (new_help
, _("[enabled]"));
1715 strcat (new_help
, _("[disabled]"));
1722 if (option
->range_max
!= -1)
1725 snprintf (b
, sizeof (b
), "<%d,%d>", option
->range_min
,
1727 opt
= concat (opt
, b
, NULL
);
1731 wrap_help (help
, opt
, len
, columns
);
1734 if (option
->var_type
== CLVC_ENUM
1735 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1736 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1739 vec
<const char *> option_values
1740 = targetm_common
.get_valid_option_values (i
, NULL
);
1741 if (!option_values
.is_empty ())
1742 help_tuples
.safe_push (option_help_tuple (i
, option_values
));
1748 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1751 printf (_(" No options with the desired characteristics were found\n"));
1756 /* PR 31349: Tell the user how to see all of the
1757 options supported by a specific front end. */
1758 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1759 if ((1U << i
) & langs
)
1760 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1761 lang_names
[i
], lang_names
[i
]);
1765 else if (! displayed
)
1766 printf (_(" All options with the desired characteristics have already been displayed\n"));
1770 /* Print details of enumerated option arguments, if those
1771 enumerations have help text headings provided. If no help text
1772 is provided, presume that the possible values are listed in the
1773 help text for the relevant options. */
1774 for (i
= 0; i
< cl_enums_count
; i
++)
1776 unsigned int j
, pos
;
1778 if (opts
->x_help_enum_printed
[i
] != 1)
1780 if (cl_enums
[i
].help
== NULL
)
1782 printf (" %s\n ", _(cl_enums
[i
].help
));
1784 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1786 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1788 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1790 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1800 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1805 opts
->x_help_enum_printed
[i
] = 2;
1808 for (unsigned i
= 0; i
< help_tuples
.length (); i
++)
1810 const struct cl_option
*option
= cl_options
+ help_tuples
[i
].m_code
;
1811 printf (_(" Known valid arguments for %s option:\n "),
1813 for (unsigned j
= 0; j
< help_tuples
[i
].m_values
.length (); j
++)
1814 printf (" %s", help_tuples
[i
].m_values
[j
]);
1819 /* Display help for a specified type of option.
1820 The options must have ALL of the INCLUDE_FLAGS set
1821 ANY of the flags in the ANY_FLAGS set
1822 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1823 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1825 print_specific_help (unsigned int include_flags
,
1826 unsigned int exclude_flags
,
1827 unsigned int any_flags
,
1828 struct gcc_options
*opts
,
1829 unsigned int lang_mask
)
1831 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1832 const char * description
= NULL
;
1833 const char * descrip_extra
= "";
1837 /* Sanity check: Make sure that we do not have more
1838 languages than we have bits available to enumerate them. */
1839 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1841 /* If we have not done so already, obtain
1842 the desired maximum width of the output. */
1843 if (opts
->x_help_columns
== 0)
1845 opts
->x_help_columns
= get_terminal_width ();
1846 if (opts
->x_help_columns
== INT_MAX
)
1847 /* Use a reasonable default. */
1848 opts
->x_help_columns
= 80;
1851 /* Decide upon the title for the options that we are going to display. */
1852 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1854 switch (flag
& include_flags
)
1861 description
= _("The following options are target specific");
1864 description
= _("The following options control compiler warning messages");
1866 case CL_OPTIMIZATION
:
1867 description
= _("The following options control optimizations");
1870 description
= _("The following options are language-independent");
1873 description
= _("The following options control parameters");
1876 if (i
>= cl_lang_count
)
1878 if (exclude_flags
& all_langs_mask
)
1879 description
= _("The following options are specific to just the language ");
1881 description
= _("The following options are supported by the language ");
1882 descrip_extra
= lang_names
[i
];
1887 if (description
== NULL
)
1891 if (include_flags
& CL_UNDOCUMENTED
)
1892 description
= _("The following options are not documented");
1893 else if (include_flags
& CL_SEPARATE
)
1894 description
= _("The following options take separate arguments");
1895 else if (include_flags
& CL_JOINED
)
1896 description
= _("The following options take joined arguments");
1899 internal_error ("unrecognized %<include_flags 0x%x%> passed "
1900 "to %<print_specific_help%>",
1907 if (any_flags
& all_langs_mask
)
1908 description
= _("The following options are language-related");
1910 description
= _("The following options are language-independent");
1914 printf ("%s%s:\n", description
, descrip_extra
);
1915 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
1916 opts
->x_help_columns
, opts
, lang_mask
);
1919 /* Enable FDO-related flags. */
1922 enable_fdo_optimizations (struct gcc_options
*opts
,
1923 struct gcc_options
*opts_set
,
1926 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_branch_probabilities
, value
);
1927 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
1928 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_loops
, value
);
1929 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_peel_loops
, value
);
1930 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tracer
, value
);
1931 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_value_profile_transformations
,
1933 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
1934 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp
, value
);
1937 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp_clone
, 1);
1938 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, 1);
1940 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_predictive_commoning
, value
);
1941 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_split_loops
, value
);
1942 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unswitch_loops
, value
);
1943 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_gcse_after_reload
, value
);
1944 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_vectorize
, value
);
1945 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_slp_vectorize
, value
);
1946 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_version_loops_for_strides
, value
);
1947 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_vect_cost_model
,
1948 VECT_COST_MODEL_DYNAMIC
);
1949 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribute_patterns
,
1951 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_loop_interchange
, value
);
1952 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_jam
, value
);
1953 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribution
, value
);
1956 /* -f{,no-}sanitize{,-recover}= suboptions. */
1957 const struct sanitizer_opts_s sanitizer_opts
[] =
1959 #define SANITIZER_OPT(name, flags, recover) \
1960 { #name, flags, sizeof #name - 1, recover }
1961 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true),
1962 SANITIZER_OPT (hwaddress
, (SANITIZE_HWADDRESS
| SANITIZE_USER_HWADDRESS
),
1964 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
1966 SANITIZER_OPT (kernel
-hwaddress
,
1967 (SANITIZE_HWADDRESS
| SANITIZE_KERNEL_HWADDRESS
),
1969 SANITIZER_OPT (pointer
-compare
, SANITIZE_POINTER_COMPARE
, true),
1970 SANITIZER_OPT (pointer
-subtract
, SANITIZE_POINTER_SUBTRACT
, true),
1971 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false),
1972 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false),
1973 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true),
1974 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true),
1975 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true),
1976 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true),
1977 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true),
1978 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false),
1979 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true),
1980 SANITIZER_OPT (return, SANITIZE_RETURN
, false),
1981 SANITIZER_OPT (null
, SANITIZE_NULL
, true),
1982 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true),
1983 SANITIZER_OPT (bool, SANITIZE_BOOL
, true),
1984 SANITIZER_OPT (enum, SANITIZE_ENUM
, true),
1985 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true),
1986 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true),
1987 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true),
1988 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true),
1989 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true),
1990 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true),
1991 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
1993 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true),
1994 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true),
1995 SANITIZER_OPT (pointer
-overflow
, SANITIZE_POINTER_OVERFLOW
, true),
1996 SANITIZER_OPT (builtin
, SANITIZE_BUILTIN
, true),
1997 SANITIZER_OPT (all
, ~0U, true),
1998 #undef SANITIZER_OPT
1999 { NULL
, 0U, 0UL, false }
2002 /* -fzero-call-used-regs= suboptions. */
2003 const struct zero_call_used_regs_opts_s zero_call_used_regs_opts
[] =
2005 #define ZERO_CALL_USED_REGS_OPT(name, flags) \
2007 ZERO_CALL_USED_REGS_OPT (skip
, zero_regs_flags::SKIP
),
2008 ZERO_CALL_USED_REGS_OPT (used
-gpr
-arg
, zero_regs_flags::USED_GPR_ARG
),
2009 ZERO_CALL_USED_REGS_OPT (used
-gpr
, zero_regs_flags::USED_GPR
),
2010 ZERO_CALL_USED_REGS_OPT (used
-arg
, zero_regs_flags::USED_ARG
),
2011 ZERO_CALL_USED_REGS_OPT (used
, zero_regs_flags::USED
),
2012 ZERO_CALL_USED_REGS_OPT (all
-gpr
-arg
, zero_regs_flags::ALL_GPR_ARG
),
2013 ZERO_CALL_USED_REGS_OPT (all
-gpr
, zero_regs_flags::ALL_GPR
),
2014 ZERO_CALL_USED_REGS_OPT (all
-arg
, zero_regs_flags::ALL_ARG
),
2015 ZERO_CALL_USED_REGS_OPT (all
, zero_regs_flags::ALL
),
2016 #undef ZERO_CALL_USED_REGS_OPT
2020 /* A struct for describing a run of chars within a string. */
2022 class string_fragment
2025 string_fragment (const char *start
, size_t len
)
2026 : m_start (start
), m_len (len
) {}
2028 const char *m_start
;
2032 /* Specialization of edit_distance_traits for string_fragment,
2033 for use by get_closest_sanitizer_option. */
2036 struct edit_distance_traits
<const string_fragment
&>
2038 static size_t get_length (const string_fragment
&fragment
)
2040 return fragment
.m_len
;
2043 static const char *get_string (const string_fragment
&fragment
)
2045 return fragment
.m_start
;
2049 /* Given ARG, an unrecognized sanitizer option, return the best
2050 matching sanitizer option, or NULL if there isn't one.
2051 OPTS is array of candidate sanitizer options.
2052 CODE is OPT_fsanitize_ or OPT_fsanitize_recover_.
2053 VALUE is non-zero for the regular form of the option, zero
2054 for the "no-" form (e.g. "-fno-sanitize-recover="). */
2057 get_closest_sanitizer_option (const string_fragment
&arg
,
2058 const struct sanitizer_opts_s
*opts
,
2059 enum opt_code code
, int value
)
2061 best_match
<const string_fragment
&, const char*> bm (arg
);
2062 for (int i
= 0; opts
[i
].name
!= NULL
; ++i
)
2064 /* -fsanitize=all is not valid, so don't offer it. */
2065 if (code
== OPT_fsanitize_
2066 && opts
[i
].flag
== ~0U
2070 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
2071 don't offer the non-recoverable options. */
2072 if (code
== OPT_fsanitize_recover_
2073 && !opts
[i
].can_recover
2077 bm
.consider (opts
[i
].name
);
2079 return bm
.get_best_meaningful_candidate ();
2082 /* Parse comma separated sanitizer suboptions from P for option SCODE,
2083 adjust previous FLAGS and return new ones. If COMPLAIN is false,
2084 don't issue diagnostics. */
2087 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
2088 unsigned int flags
, int value
, bool complain
)
2090 enum opt_code code
= (enum opt_code
) scode
;
2096 const char *comma
= strchr (p
, ',');
2108 /* Check to see if the string matches an option class name. */
2109 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
2110 if (len
== sanitizer_opts
[i
].len
2111 && memcmp (p
, sanitizer_opts
[i
].name
, len
) == 0)
2113 /* Handle both -fsanitize and -fno-sanitize cases. */
2114 if (value
&& sanitizer_opts
[i
].flag
== ~0U)
2116 if (code
== OPT_fsanitize_
)
2119 error_at (loc
, "%<-fsanitize=all%> option is not valid");
2122 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
2123 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2127 /* Do not enable -fsanitize-recover=unreachable and
2128 -fsanitize-recover=return if -fsanitize-recover=undefined
2130 if (code
== OPT_fsanitize_recover_
2131 && sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
2132 flags
|= (SANITIZE_UNDEFINED
2133 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
2135 flags
|= sanitizer_opts
[i
].flag
;
2138 flags
&= ~sanitizer_opts
[i
].flag
;
2143 if (! found
&& complain
)
2146 = get_closest_sanitizer_option (string_fragment (p
, len
),
2147 sanitizer_opts
, code
, value
);
2150 if (code
== OPT_fsanitize_recover_
)
2151 suffix
= "-recover";
2157 "unrecognized argument to %<-f%ssanitize%s=%> "
2158 "option: %q.*s; did you mean %qs?",
2160 suffix
, (int) len
, p
, hint
);
2163 "unrecognized argument to %<-f%ssanitize%s=%> option: "
2164 "%q.*s", value
? "" : "no-",
2165 suffix
, (int) len
, p
);
2175 /* Parse string values of no_sanitize attribute passed in VALUE.
2176 Values are separated with comma. */
2179 parse_no_sanitize_attribute (char *value
)
2181 unsigned int flags
= 0;
2183 char *q
= strtok (value
, ",");
2187 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
2188 if (strcmp (sanitizer_opts
[i
].name
, q
) == 0)
2190 flags
|= sanitizer_opts
[i
].flag
;
2191 if (sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
2192 flags
|= SANITIZE_UNDEFINED_NONDEFAULT
;
2196 if (sanitizer_opts
[i
].name
== NULL
)
2197 warning (OPT_Wattributes
,
2198 "%qs attribute directive ignored", q
);
2200 q
= strtok (NULL
, ",");
2206 /* Parse -fzero-call-used-regs suboptions from ARG, return the FLAGS. */
2209 parse_zero_call_used_regs_options (const char *arg
)
2211 unsigned int flags
= 0;
2213 /* Check to see if the string matches a sub-option name. */
2214 for (unsigned int i
= 0; zero_call_used_regs_opts
[i
].name
!= NULL
; ++i
)
2215 if (strcmp (arg
, zero_call_used_regs_opts
[i
].name
) == 0)
2217 flags
= zero_call_used_regs_opts
[i
].flag
;
2222 error ("unrecognized argument to %<-fzero-call-used-regs=%>: %qs", arg
);
2227 /* Parse -falign-NAME format for a FLAG value. Return individual
2228 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
2229 set, print error message at LOC location. */
2232 parse_and_check_align_values (const char *flag
,
2234 auto_vec
<unsigned> &result_values
,
2238 char *str
= xstrdup (flag
);
2239 for (char *p
= strtok (str
, ":"); p
; p
= strtok (NULL
, ":"))
2242 int v
= strtol (p
, &end
, 10);
2243 if (*end
!= '\0' || v
< 0)
2246 error_at (loc
, "invalid arguments for %<-falign-%s%> option: %qs",
2252 result_values
.safe_push ((unsigned)v
);
2257 /* Check that we have a correct number of values. */
2258 if (result_values
.is_empty () || result_values
.length () > 4)
2261 error_at (loc
, "invalid number of arguments for %<-falign-%s%> "
2262 "option: %qs", name
, flag
);
2266 for (unsigned i
= 0; i
< result_values
.length (); i
++)
2267 if (result_values
[i
] > MAX_CODE_ALIGN_VALUE
)
2270 error_at (loc
, "%<-falign-%s%> is not between 0 and %d",
2271 name
, MAX_CODE_ALIGN_VALUE
);
2278 /* Check that alignment value FLAG for -falign-NAME is valid at a given
2279 location LOC. OPT_STR points to the stored -falign-NAME=argument and
2280 OPT_FLAG points to the associated -falign-NAME on/off flag. */
2283 check_alignment_argument (location_t loc
, const char *flag
, const char *name
,
2284 int *opt_flag
, const char **opt_str
)
2286 auto_vec
<unsigned> align_result
;
2287 parse_and_check_align_values (flag
, name
, align_result
, true, loc
);
2289 if (align_result
.length() >= 1 && align_result
[0] == 0)
2296 /* Parse argument of -fpatchable-function-entry option ARG and store
2297 corresponding values to PATCH_AREA_SIZE and PATCH_AREA_START.
2298 If REPORT_ERROR is set to true, generate error for a problematic
2299 option arguments. */
2302 parse_and_check_patch_area (const char *arg
, bool report_error
,
2303 HOST_WIDE_INT
*patch_area_size
,
2304 HOST_WIDE_INT
*patch_area_start
)
2306 *patch_area_size
= 0;
2307 *patch_area_start
= 0;
2312 char *patch_area_arg
= xstrdup (arg
);
2313 char *comma
= strchr (patch_area_arg
, ',');
2317 *patch_area_size
= integral_argument (patch_area_arg
);
2318 *patch_area_start
= integral_argument (comma
+ 1);
2321 *patch_area_size
= integral_argument (patch_area_arg
);
2323 if (*patch_area_size
< 0
2324 || *patch_area_size
> USHRT_MAX
2325 || *patch_area_start
< 0
2326 || *patch_area_start
> USHRT_MAX
2327 || *patch_area_size
< *patch_area_start
)
2329 error ("invalid arguments for %<-fpatchable-function-entry%>");
2331 free (patch_area_arg
);
2334 /* Print help when OPT__help_ is set. */
2337 print_help (struct gcc_options
*opts
, unsigned int lang_mask
,
2338 const char *help_option_argument
)
2340 const char *a
= help_option_argument
;
2341 unsigned int include_flags
= 0;
2342 /* Note - by default we include undocumented options when listing
2343 specific classes. If you only want to see documented options
2344 then add ",^undocumented" to the --help= option. E.g.:
2346 --help=target,^undocumented */
2347 unsigned int exclude_flags
= 0;
2349 if (lang_mask
== CL_DRIVER
)
2352 /* Walk along the argument string, parsing each word in turn.
2354 arg = [^]{word}[,{arg}]
2355 word = {optimizers|target|warnings|undocumented|
2356 params|common|<language>} */
2366 { "optimizers", CL_OPTIMIZATION
},
2367 { "target", CL_TARGET
},
2368 { "warnings", CL_WARNING
},
2369 { "undocumented", CL_UNDOCUMENTED
},
2370 { "params", CL_PARAMS
},
2371 { "joined", CL_JOINED
},
2372 { "separate", CL_SEPARATE
},
2373 { "common", CL_COMMON
},
2376 unsigned int *pflags
;
2378 unsigned int lang_flag
, specific_flag
;
2387 error ("missing argument to %qs", "--help=^");
2390 pflags
= &exclude_flags
;
2393 pflags
= &include_flags
;
2395 comma
= strchr (a
, ',');
2406 /* Check to see if the string matches an option class name. */
2407 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
2408 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
2410 specific_flag
= specifics
[i
].flag
;
2414 /* Check to see if the string matches a language name.
2415 Note - we rely upon the alpha-sorted nature of the entries in
2416 the lang_names array, specifically that shorter names appear
2417 before their longer variants. (i.e. C before C++). That way
2418 when we are attempting to match --help=c for example we will
2419 match with C first and not C++. */
2420 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
2421 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
2423 lang_flag
= 1U << i
;
2427 if (specific_flag
!= 0)
2430 *pflags
|= specific_flag
;
2433 /* The option's argument matches both the start of a
2434 language name and the start of an option class name.
2435 We have a special case for when the user has
2436 specified "--help=c", but otherwise we have to issue
2438 if (strncasecmp (a
, "c", len
) == 0)
2439 *pflags
|= lang_flag
;
2442 "%<--help%> argument %q.*s is ambiguous, "
2443 "please be more specific",
2447 else if (lang_flag
!= 0)
2448 *pflags
|= lang_flag
;
2451 "unrecognized argument to %<--help=%> option: %q.*s",
2459 /* We started using PerFunction/Optimization for parameters and
2460 a warning. We should exclude these from optimization options. */
2461 if (include_flags
& CL_OPTIMIZATION
)
2462 exclude_flags
|= CL_WARNING
;
2463 if (!(include_flags
& CL_PARAMS
))
2464 exclude_flags
|= CL_PARAMS
;
2467 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
2471 /* Handle target- and language-independent options. Return zero to
2472 generate an "unknown option" message. Only options that need
2473 extra handling need to be listed here; if you simply want
2474 DECODED->value assigned to a variable, it happens automatically. */
2477 common_handle_option (struct gcc_options
*opts
,
2478 struct gcc_options
*opts_set
,
2479 const struct cl_decoded_option
*decoded
,
2480 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
2482 const struct cl_option_handlers
*handlers
,
2483 diagnostic_context
*dc
,
2484 void (*target_option_override_hook
) (void))
2486 size_t scode
= decoded
->opt_index
;
2487 const char *arg
= decoded
->arg
;
2488 HOST_WIDE_INT value
= decoded
->value
;
2489 enum opt_code code
= (enum opt_code
) scode
;
2491 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
2497 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
2498 unsigned int undoc_mask
;
2501 if (lang_mask
== CL_DRIVER
)
2504 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
2507 target_option_override_hook ();
2508 /* First display any single language specific options. */
2509 for (i
= 0; i
< cl_lang_count
; i
++)
2511 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
2513 /* Next display any multi language specific options. */
2514 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
2515 /* Then display any remaining, non-language options. */
2516 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
2518 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
2519 opts
->x_exit_after_options
= true;
2523 case OPT__target_help
:
2524 if (lang_mask
== CL_DRIVER
)
2527 target_option_override_hook ();
2528 print_specific_help (CL_TARGET
, CL_UNDOCUMENTED
, 0, opts
, lang_mask
);
2529 opts
->x_exit_after_options
= true;
2534 help_option_arguments
.safe_push (arg
);
2535 opts
->x_exit_after_options
= true;
2540 if (lang_mask
== CL_DRIVER
)
2543 opts
->x_exit_after_options
= true;
2546 case OPT__completion_
:
2549 case OPT_fsanitize_
:
2550 opts
->x_flag_sanitize
2551 = parse_sanitizer_options (arg
, loc
, code
,
2552 opts
->x_flag_sanitize
, value
, true);
2554 /* Kernel ASan implies normal ASan but does not yet support
2556 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
2558 SET_OPTION_IF_UNSET (opts
, opts_set
,
2559 param_asan_instrumentation_with_call_threshold
,
2561 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_globals
, 0);
2562 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_stack
, 0);
2563 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_protect_allocas
, 0);
2564 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_use_after_return
, 0);
2566 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_HWADDRESS
)
2568 SET_OPTION_IF_UNSET (opts
, opts_set
,
2569 param_hwasan_instrument_stack
, 0);
2570 SET_OPTION_IF_UNSET (opts
, opts_set
,
2571 param_hwasan_random_frame_tag
, 0);
2572 SET_OPTION_IF_UNSET (opts
, opts_set
,
2573 param_hwasan_instrument_allocas
, 0);
2577 case OPT_fsanitize_recover_
:
2578 opts
->x_flag_sanitize_recover
2579 = parse_sanitizer_options (arg
, loc
, code
,
2580 opts
->x_flag_sanitize_recover
, value
, true);
2583 case OPT_fasan_shadow_offset_
:
2587 case OPT_fsanitize_address_use_after_scope
:
2588 opts
->x_flag_sanitize_address_use_after_scope
= value
;
2591 case OPT_fsanitize_recover
:
2593 opts
->x_flag_sanitize_recover
2594 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)
2595 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2597 opts
->x_flag_sanitize_recover
2598 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2601 case OPT_fsanitize_coverage_
:
2602 opts
->x_flag_sanitize_coverage
= value
;
2609 /* Currently handled in a prescan. */
2613 dc
->warning_as_error_requested
= value
;
2617 if (lang_mask
== CL_DRIVER
)
2620 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
2621 opts
, opts_set
, loc
, dc
);
2624 case OPT_Wfatal_errors
:
2625 dc
->fatal_errors
= value
;
2628 case OPT_Wstack_usage_
:
2629 opts
->x_flag_stack_usage_info
= value
!= -1;
2632 case OPT_Wstrict_aliasing
:
2633 set_Wstrict_aliasing (opts
, value
);
2636 case OPT_Wstrict_overflow
:
2637 opts
->x_warn_strict_overflow
= (value
2638 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2642 case OPT_Wsystem_headers
:
2643 dc
->dc_warn_system_headers
= value
;
2647 opts
->x_flag_gen_aux_info
= 1;
2651 decode_d_option (arg
, opts
, loc
, dc
);
2654 case OPT_fcall_used_
:
2655 case OPT_fcall_saved_
:
2663 case OPT_fdebug_prefix_map_
:
2664 case OPT_ffile_prefix_map_
:
2668 case OPT_fcallgraph_info
:
2669 opts
->x_flag_callgraph_info
= CALLGRAPH_INFO_NAKED
;
2672 case OPT_fcallgraph_info_
:
2675 my_arg
= xstrdup (arg
);
2676 p
= strtok (my_arg
, ",");
2679 if (strcmp (p
, "su") == 0)
2681 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_STACK_USAGE
;
2682 opts
->x_flag_stack_usage_info
= true;
2684 else if (strcmp (p
, "da") == 0)
2685 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_DYNAMIC_ALLOC
;
2688 p
= strtok (NULL
, ",");
2694 case OPT_fdiagnostics_show_location_
:
2695 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2698 case OPT_fdiagnostics_show_caret
:
2699 dc
->show_caret
= value
;
2702 case OPT_fdiagnostics_show_labels
:
2703 dc
->show_labels_p
= value
;
2706 case OPT_fdiagnostics_show_line_numbers
:
2707 dc
->show_line_numbers_p
= value
;
2710 case OPT_fdiagnostics_color_
:
2711 diagnostic_color_init (dc
, value
);
2714 case OPT_fdiagnostics_urls_
:
2715 diagnostic_urls_init (dc
, value
);
2718 case OPT_fdiagnostics_format_
:
2719 diagnostic_output_format_init (dc
,
2720 (enum diagnostics_output_format
)value
);
2723 case OPT_fdiagnostics_parseable_fixits
:
2724 dc
->extra_output_kind
= (value
2725 ? EXTRA_DIAGNOSTIC_OUTPUT_fixits_v1
2726 : EXTRA_DIAGNOSTIC_OUTPUT_none
);
2729 case OPT_fdiagnostics_column_unit_
:
2730 dc
->column_unit
= (enum diagnostics_column_unit
)value
;
2733 case OPT_fdiagnostics_column_origin_
:
2734 dc
->column_origin
= value
;
2737 case OPT_fdiagnostics_show_cwe
:
2738 dc
->show_cwe
= value
;
2741 case OPT_fdiagnostics_path_format_
:
2742 dc
->path_format
= (enum diagnostic_path_format
)value
;
2745 case OPT_fdiagnostics_show_path_depths
:
2746 dc
->show_path_depths
= value
;
2749 case OPT_fdiagnostics_show_option
:
2750 dc
->show_option_requested
= value
;
2753 case OPT_fdiagnostics_minimum_margin_width_
:
2754 dc
->min_margin_width
= value
;
2761 case OPT_ffast_math
:
2762 set_fast_math_flags (opts
, value
);
2765 case OPT_funsafe_math_optimizations
:
2766 set_unsafe_math_optimizations_flags (opts
, value
);
2773 case OPT_finline_limit_
:
2774 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_single
,
2776 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_auto
,
2780 case OPT_finstrument_functions_exclude_function_list_
:
2781 add_comma_separated_to_vector
2782 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2785 case OPT_finstrument_functions_exclude_file_list_
:
2786 add_comma_separated_to_vector
2787 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2790 case OPT_fmessage_length_
:
2791 pp_set_line_maximum_length (dc
->printer
, value
);
2792 diagnostic_set_caret_max_width (dc
, value
);
2796 case OPT_fopt_info_
:
2800 case OPT_foffload_options_
:
2804 case OPT_foffload_abi_
:
2805 #ifdef ACCEL_COMPILER
2806 /* Handled in the 'mkoffload's. */
2808 error_at (loc
, "%<-foffload-abi%> option can be specified only for "
2809 "offload compiler");
2813 case OPT_fpack_struct_
:
2814 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2816 "structure alignment must be a small power of two, not %wu",
2819 opts
->x_initial_max_fld_align
= value
;
2823 case OPT_fplugin_arg_
:
2827 case OPT_fprofile_use_
:
2828 opts
->x_profile_data_prefix
= xstrdup (arg
);
2829 opts
->x_flag_profile_use
= true;
2831 /* No break here - do -fprofile-use processing. */
2833 case OPT_fprofile_use
:
2834 enable_fdo_optimizations (opts
, opts_set
, value
);
2835 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_reorder_functions
,
2837 /* Indirect call profiling should do all useful transformations
2838 speculative devirtualization does. */
2839 if (opts
->x_flag_value_profile_transformations
)
2840 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_devirtualize_speculatively
,
2844 case OPT_fauto_profile_
:
2845 opts
->x_auto_profile_file
= xstrdup (arg
);
2846 opts
->x_flag_auto_profile
= true;
2848 /* No break here - do -fauto-profile processing. */
2850 case OPT_fauto_profile
:
2851 enable_fdo_optimizations (opts
, opts_set
, value
);
2852 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_correction
, value
);
2853 SET_OPTION_IF_UNSET (opts
, opts_set
,
2854 param_early_inliner_max_iterations
, 10);
2857 case OPT_fprofile_generate_
:
2858 opts
->x_profile_data_prefix
= xstrdup (arg
);
2860 /* No break here - do -fprofile-generate processing. */
2862 case OPT_fprofile_generate
:
2863 SET_OPTION_IF_UNSET (opts
, opts_set
, profile_arc_flag
, value
);
2864 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
2865 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
2866 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, value
);
2869 case OPT_fprofile_info_section
:
2870 opts
->x_profile_info_section
= ".gcov_info";
2873 case OPT_fpatchable_function_entry_
:
2875 HOST_WIDE_INT patch_area_size
, patch_area_start
;
2876 parse_and_check_patch_area (arg
, true, &patch_area_size
,
2881 case OPT_ftree_vectorize
:
2882 /* Automatically sets -ftree-loop-vectorize and
2883 -ftree-slp-vectorize. Nothing more to do here. */
2885 case OPT_fzero_call_used_regs_
:
2886 opts
->x_flag_zero_call_used_regs
2887 = parse_zero_call_used_regs_options (arg
);
2890 case OPT_fshow_column
:
2891 dc
->show_column
= value
;
2894 case OPT_frandom_seed
:
2895 /* The real switch is -fno-random-seed. */
2901 case OPT_frandom_seed_
:
2905 case OPT_fsched_verbose_
:
2906 #ifdef INSN_SCHEDULING
2907 /* Handled with Var in common.opt. */
2913 case OPT_fsched_stalled_insns_
:
2914 opts
->x_flag_sched_stalled_insns
= value
;
2915 if (opts
->x_flag_sched_stalled_insns
== 0)
2916 opts
->x_flag_sched_stalled_insns
= -1;
2919 case OPT_fsched_stalled_insns_dep_
:
2920 opts
->x_flag_sched_stalled_insns_dep
= value
;
2923 case OPT_fstack_check_
:
2924 if (!strcmp (arg
, "no"))
2925 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
2926 else if (!strcmp (arg
, "generic"))
2927 /* This is the old stack checking method. */
2928 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2929 ? FULL_BUILTIN_STACK_CHECK
2930 : GENERIC_STACK_CHECK
;
2931 else if (!strcmp (arg
, "specific"))
2932 /* This is the new stack checking method. */
2933 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2934 ? FULL_BUILTIN_STACK_CHECK
2935 : STACK_CHECK_STATIC_BUILTIN
2936 ? STATIC_BUILTIN_STACK_CHECK
2937 : GENERIC_STACK_CHECK
;
2939 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
2942 case OPT_fstack_limit
:
2943 /* The real switch is -fno-stack-limit. */
2949 case OPT_fstack_limit_register_
:
2950 case OPT_fstack_limit_symbol_
:
2954 case OPT_fstack_usage
:
2955 opts
->x_flag_stack_usage
= value
;
2956 opts
->x_flag_stack_usage_info
= value
!= 0;
2960 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
2965 set_debug_level (BTF_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2966 /* set the debug level to level 2, but if already at level 3,
2968 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
2969 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
2973 set_debug_level (CTF_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2974 /* CTF generation feeds off DWARF dies. For optimal CTF, switch debug
2975 info level to 2. If off or at level 1, set it to level 2, but if
2976 already at level 3, don't lower it. */
2977 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
2978 && opts
->x_ctf_debug_info_level
> CTFINFO_LEVEL_NONE
)
2979 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
2983 if (arg
&& strlen (arg
) != 0)
2985 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
2986 "use %<-gdwarf-%s%> for DWARF version "
2987 "or %<-gdwarf%> %<-g%s%> for debug level", arg
, arg
, arg
);
2991 value
= opts
->x_dwarf_version
;
2995 if (value
< 2 || value
> 5)
2996 error_at (loc
, "dwarf version %wu is not supported", value
);
2998 opts
->x_dwarf_version
= value
;
2999 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
3003 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
3008 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
, opts
, opts_set
,
3013 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
3018 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
, opts
, opts_set
,
3024 /* Handled completely via specs. */
3027 case OPT_pedantic_errors
:
3028 dc
->pedantic_errors
= 1;
3029 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
3031 handlers
, opts
, opts_set
,
3036 opts
->x_flag_lto
= value
? "" : NULL
;
3040 if (strcmp (arg
, "none") != 0
3041 && strcmp (arg
, "jobserver") != 0
3042 && strcmp (arg
, "auto") != 0
3045 "unrecognized argument to %<-flto=%> option: %qs", arg
);
3049 dc
->dc_inhibit_warnings
= true;
3052 case OPT_fmax_errors_
:
3053 dc
->max_errors
= value
;
3056 case OPT_fuse_ld_bfd
:
3057 case OPT_fuse_ld_gold
:
3058 case OPT_fuse_ld_lld
:
3059 case OPT_fuse_linker_plugin
:
3060 /* No-op. Used by the driver and passed to us because it starts with f.*/
3065 opts
->x_flag_trapv
= 0;
3070 opts
->x_flag_wrapv
= 0;
3073 case OPT_fstrict_overflow
:
3074 opts
->x_flag_wrapv
= !value
;
3075 opts
->x_flag_wrapv_pointer
= !value
;
3077 opts
->x_flag_trapv
= 0;
3081 opts
->x_flag_ipa_icf_functions
= value
;
3082 opts
->x_flag_ipa_icf_variables
= value
;
3085 case OPT_falign_loops_
:
3086 check_alignment_argument (loc
, arg
, "loops",
3087 &opts
->x_flag_align_loops
,
3088 &opts
->x_str_align_loops
);
3091 case OPT_falign_jumps_
:
3092 check_alignment_argument (loc
, arg
, "jumps",
3093 &opts
->x_flag_align_jumps
,
3094 &opts
->x_str_align_jumps
);
3097 case OPT_falign_labels_
:
3098 check_alignment_argument (loc
, arg
, "labels",
3099 &opts
->x_flag_align_labels
,
3100 &opts
->x_str_align_labels
);
3103 case OPT_falign_functions_
:
3104 check_alignment_argument (loc
, arg
, "functions",
3105 &opts
->x_flag_align_functions
,
3106 &opts
->x_str_align_functions
);
3110 /* It is documented that we silently ignore silly values. */
3111 if (value
>= 1 && value
<= 100)
3112 dc
->tabstop
= value
;
3116 /* If the flag was handled in a standard way, assume the lack of
3117 processing here is intentional. */
3118 gcc_assert (option_flag_var (scode
, opts
));
3122 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
3127 /* Used to set the level of strict aliasing warnings in OPTS,
3128 when no level is specified (i.e., when -Wstrict-aliasing, and not
3129 -Wstrict-aliasing=level was given).
3130 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
3131 and 0 otherwise. After calling this function, wstrict_aliasing will be
3132 set to the default value of -Wstrict_aliasing=level, currently 3. */
3134 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
3136 gcc_assert (onoff
== 0 || onoff
== 1);
3138 opts
->x_warn_strict_aliasing
= 3;
3140 opts
->x_warn_strict_aliasing
= 0;
3143 /* The following routines are useful in setting all the flags that
3144 -ffast-math and -fno-fast-math imply. */
3146 set_fast_math_flags (struct gcc_options
*opts
, int set
)
3148 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
3150 opts
->x_flag_unsafe_math_optimizations
= set
;
3151 set_unsafe_math_optimizations_flags (opts
, set
);
3153 if (!opts
->frontend_set_flag_finite_math_only
)
3154 opts
->x_flag_finite_math_only
= set
;
3155 if (!opts
->frontend_set_flag_errno_math
)
3156 opts
->x_flag_errno_math
= !set
;
3159 if (opts
->frontend_set_flag_excess_precision
== EXCESS_PRECISION_DEFAULT
)
3160 opts
->x_flag_excess_precision
3161 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
3162 if (!opts
->frontend_set_flag_signaling_nans
)
3163 opts
->x_flag_signaling_nans
= 0;
3164 if (!opts
->frontend_set_flag_rounding_math
)
3165 opts
->x_flag_rounding_math
= 0;
3166 if (!opts
->frontend_set_flag_cx_limited_range
)
3167 opts
->x_flag_cx_limited_range
= 1;
3171 /* When -funsafe-math-optimizations is set the following
3172 flags are set as well. */
3174 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
3176 if (!opts
->frontend_set_flag_trapping_math
)
3177 opts
->x_flag_trapping_math
= !set
;
3178 if (!opts
->frontend_set_flag_signed_zeros
)
3179 opts
->x_flag_signed_zeros
= !set
;
3180 if (!opts
->frontend_set_flag_associative_math
)
3181 opts
->x_flag_associative_math
= set
;
3182 if (!opts
->frontend_set_flag_reciprocal_math
)
3183 opts
->x_flag_reciprocal_math
= set
;
3186 /* Return true iff flags in OPTS are set as if -ffast-math. */
3188 fast_math_flags_set_p (const struct gcc_options
*opts
)
3190 return (!opts
->x_flag_trapping_math
3191 && opts
->x_flag_unsafe_math_optimizations
3192 && opts
->x_flag_finite_math_only
3193 && !opts
->x_flag_signed_zeros
3194 && !opts
->x_flag_errno_math
3195 && opts
->x_flag_excess_precision
== EXCESS_PRECISION_FAST
);
3198 /* Return true iff flags are set as if -ffast-math but using the flags stored
3199 in the struct cl_optimization structure. */
3201 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
3203 return (!opt
->x_flag_trapping_math
3204 && opt
->x_flag_unsafe_math_optimizations
3205 && opt
->x_flag_finite_math_only
3206 && !opt
->x_flag_signed_zeros
3207 && !opt
->x_flag_errno_math
);
3210 /* Handle a debug output -g switch for options OPTS
3211 (OPTS_SET->x_write_symbols storing whether a debug format was passed
3212 explicitly), location LOC. EXTENDED is true or false to support
3213 extended output (2 is special and means "-ggdb" was given). */
3215 set_debug_level (uint32_t dinfo
, int extended
, const char *arg
,
3216 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
3219 opts
->x_use_gnu_debug_info_extensions
= extended
;
3221 if (dinfo
== NO_DEBUG
)
3223 if (opts
->x_write_symbols
== NO_DEBUG
)
3225 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
3229 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
3230 if (opts
->x_write_symbols
& CTF_DEBUG
)
3231 opts
->x_write_symbols
|= DWARF2_DEBUG
;
3233 opts
->x_write_symbols
= DWARF2_DEBUG
;
3234 #elif defined DBX_DEBUGGING_INFO
3235 opts
->x_write_symbols
= DBX_DEBUG
;
3239 if (opts
->x_write_symbols
== NO_DEBUG
)
3240 warning_at (loc
, 0, "target system does not support debug output");
3242 else if ((opts
->x_write_symbols
& CTF_DEBUG
)
3243 || (opts
->x_write_symbols
& BTF_DEBUG
))
3245 opts
->x_write_symbols
|= DWARF2_DEBUG
;
3246 opts_set
->x_write_symbols
|= DWARF2_DEBUG
;
3251 /* Make and retain the choice if both CTF and DWARF debug info are to
3253 if (((dinfo
== DWARF2_DEBUG
) || (dinfo
== CTF_DEBUG
))
3254 && ((opts
->x_write_symbols
== (DWARF2_DEBUG
|CTF_DEBUG
))
3255 || (opts
->x_write_symbols
== DWARF2_DEBUG
)
3256 || (opts
->x_write_symbols
== CTF_DEBUG
)))
3258 opts
->x_write_symbols
|= dinfo
;
3259 opts_set
->x_write_symbols
|= dinfo
;
3261 /* However, CTF and BTF are not allowed together at this time. */
3262 else if (((dinfo
== DWARF2_DEBUG
) || (dinfo
== BTF_DEBUG
))
3263 && ((opts
->x_write_symbols
== (DWARF2_DEBUG
|BTF_DEBUG
))
3264 || (opts
->x_write_symbols
== DWARF2_DEBUG
)
3265 || (opts
->x_write_symbols
== BTF_DEBUG
)))
3267 opts
->x_write_symbols
|= dinfo
;
3268 opts_set
->x_write_symbols
|= dinfo
;
3272 /* Does it conflict with an already selected debug format? */
3273 if (opts_set
->x_write_symbols
!= NO_DEBUG
3274 && opts
->x_write_symbols
!= NO_DEBUG
3275 && dinfo
!= opts
->x_write_symbols
)
3277 gcc_assert (debug_set_count (dinfo
) <= 1);
3278 error_at (loc
, "debug format %qs conflicts with prior selection",
3279 debug_type_names
[debug_set_to_format (dinfo
)]);
3281 opts
->x_write_symbols
= dinfo
;
3282 opts_set
->x_write_symbols
= dinfo
;
3286 if (dinfo
!= BTF_DEBUG
)
3288 /* A debug flag without a level defaults to level 2.
3289 If off or at level 1, set it to level 2, but if already
3290 at level 3, don't lower it. */
3293 if (dinfo
== CTF_DEBUG
)
3294 opts
->x_ctf_debug_info_level
= CTFINFO_LEVEL_NORMAL
;
3295 else if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
3296 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3300 int argval
= integral_argument (arg
);
3302 error_at (loc
, "unrecognized debug output level %qs", arg
);
3303 else if (argval
> 3)
3304 error_at (loc
, "debug output level %qs is too high", arg
);
3307 if (dinfo
== CTF_DEBUG
)
3308 opts
->x_ctf_debug_info_level
3309 = (enum ctf_debug_info_levels
) argval
;
3311 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
3315 else if (*arg
!= '\0')
3316 error_at (loc
, "unrecognized btf debug output level %qs", arg
);
3319 /* Arrange to dump core on error for diagnostic context DC. (The
3320 regular error message is still printed first, except in the case of
3324 setup_core_dumping (diagnostic_context
*dc
)
3327 signal (SIGABRT
, SIG_DFL
);
3329 #if defined(HAVE_SETRLIMIT)
3332 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
3333 fatal_error (input_location
, "getting core file size maximum limit: %m");
3334 rlim
.rlim_cur
= rlim
.rlim_max
;
3335 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
3336 fatal_error (input_location
,
3337 "setting core file size limit to maximum: %m");
3340 diagnostic_abort_on_error (dc
);
3343 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
3344 diagnostic context DC. */
3347 decode_d_option (const char *arg
, struct gcc_options
*opts
,
3348 location_t loc
, diagnostic_context
*dc
)
3356 opts
->x_flag_debug_asm
= 1;
3359 opts
->x_flag_print_asm_name
= 1;
3362 opts
->x_flag_dump_rtl_in_asm
= 1;
3363 opts
->x_flag_print_asm_name
= 1;
3366 opts
->x_rtl_dump_and_exit
= 1;
3368 case 'D': /* These are handled by the preprocessor. */
3375 setup_core_dumping (dc
);
3378 opts
->x_flag_dump_all_passed
= true;
3382 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
3387 /* Enable (or disable if VALUE is 0) a warning option ARG (language
3388 mask LANG_MASK, option handlers HANDLERS) as an error for option
3389 structures OPTS and OPTS_SET, diagnostic context DC (possibly
3390 NULL), location LOC. This is used by -Werror=. */
3393 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
3394 const struct cl_option_handlers
*handlers
,
3395 struct gcc_options
*opts
,
3396 struct gcc_options
*opts_set
,
3397 location_t loc
, diagnostic_context
*dc
)
3402 new_option
= XNEWVEC (char, strlen (arg
) + 2);
3403 new_option
[0] = 'W';
3404 strcpy (new_option
+ 1, arg
);
3405 option_index
= find_opt (new_option
, lang_mask
);
3406 if (option_index
== OPT_SPECIAL_unknown
)
3409 const char *hint
= op
.suggest_option (new_option
);
3411 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>;"
3412 " did you mean %<-%s%>?", value
? "" : "no-",
3413 arg
, new_option
, hint
);
3415 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>",
3416 value
? "" : "no-", arg
, new_option
);
3418 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
3419 error_at (loc
, "%<-Werror=%s%>: %<-%s%> is not an option that "
3420 "controls warnings", arg
, new_option
);
3423 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
3424 const char *arg
= NULL
;
3426 if (cl_options
[option_index
].flags
& CL_JOINED
)
3427 arg
= new_option
+ cl_options
[option_index
].opt_len
;
3428 control_warning_option (option_index
, (int) kind
, arg
, value
,
3430 handlers
, opts
, opts_set
, dc
);
3435 /* Return malloced memory for the name of the option OPTION_INDEX
3436 which enabled a diagnostic (context CONTEXT), originally of type
3437 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
3441 option_name (diagnostic_context
*context
, int option_index
,
3442 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
3446 /* A warning classified as an error. */
3447 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
3448 && diag_kind
== DK_ERROR
)
3449 return concat (cl_options
[OPT_Werror_
].opt_text
,
3450 /* Skip over "-W". */
3451 cl_options
[option_index
].opt_text
+ 2,
3453 /* A warning with option. */
3455 return xstrdup (cl_options
[option_index
].opt_text
);
3457 /* A warning without option classified as an error. */
3458 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
3459 || diag_kind
== DK_WARNING
)
3460 && context
->warning_as_error_requested
)
3461 return xstrdup (cl_options
[OPT_Werror
].opt_text
);
3466 /* Get the page within the documentation for this option. */
3469 get_option_html_page (int option_index
)
3471 const cl_option
*cl_opt
= &cl_options
[option_index
];
3473 /* Analyzer options are on their own page. */
3474 if (strstr (cl_opt
->opt_text
, "analyzer-"))
3475 return "gcc/Static-Analyzer-Options.html";
3477 /* Handle -flto= option. */
3478 if (strstr (cl_opt
->opt_text
, "flto"))
3479 return "gcc/Optimize-Options.html";
3482 if ((cl_opt
->flags
& CL_Fortran
) != 0
3483 /* If it is option common to both C/C++ and Fortran, it is documented
3484 in gcc/ rather than gfortran/ docs. */
3485 && (cl_opt
->flags
& CL_C
) == 0
3487 && (cl_opt
->flags
& CL_CXX
) == 0
3490 return "gfortran/Error-and-Warning-Options.html";
3493 return "gcc/Warning-Options.html";
3496 /* Return malloced memory for a URL describing the option OPTION_INDEX
3497 which enabled a diagnostic (context CONTEXT). */
3500 get_option_url (diagnostic_context
*, int option_index
)
3503 return concat (/* DOCUMENTATION_ROOT_URL should be supplied via -D by
3504 the Makefile (see --with-documentation-root-url), and
3505 should have a trailing slash. */
3506 DOCUMENTATION_ROOT_URL
,
3508 /* get_option_html_page will return something like
3509 "gcc/Warning-Options.html". */
3510 get_option_html_page (option_index
),
3512 /* Expect an anchor of the form "index-Wfoo" e.g.
3513 <a name="index-Wformat"></a>, and thus an id within
3514 the URL of "#index-Wformat". */
3515 "#index", cl_options
[option_index
].opt_text
,
3521 /* Return a heap allocated producer with command line options. */
3524 gen_command_line_string (cl_decoded_option
*options
,
3525 unsigned int options_count
)
3527 auto_vec
<const char *> switches
;
3528 char *options_string
, *tail
;
3532 for (unsigned i
= 0; i
< options_count
; i
++)
3533 switch (options
[i
].opt_index
)
3538 case OPT_dumpbase_ext
:
3548 case OPT_SPECIAL_unknown
:
3549 case OPT_SPECIAL_ignore
:
3550 case OPT_SPECIAL_warn_removed
:
3551 case OPT_SPECIAL_program_name
:
3552 case OPT_SPECIAL_input_file
:
3553 case OPT_grecord_gcc_switches
:
3554 case OPT_frecord_gcc_switches
:
3555 case OPT__output_pch_
:
3556 case OPT_fdiagnostics_show_location_
:
3557 case OPT_fdiagnostics_show_option
:
3558 case OPT_fdiagnostics_show_caret
:
3559 case OPT_fdiagnostics_show_labels
:
3560 case OPT_fdiagnostics_show_line_numbers
:
3561 case OPT_fdiagnostics_color_
:
3562 case OPT_fdiagnostics_format_
:
3563 case OPT_fverbose_asm
:
3567 case OPT_nostdinc__
:
3568 case OPT_fpreprocessed
:
3569 case OPT_fltrans_output_list_
:
3570 case OPT_fresolution_
:
3571 case OPT_fdebug_prefix_map_
:
3572 case OPT_fmacro_prefix_map_
:
3573 case OPT_ffile_prefix_map_
:
3574 case OPT_fcompare_debug
:
3576 case OPT_fchecking_
:
3581 const char *lto_canonical
= "-flto";
3582 switches
.safe_push (lto_canonical
);
3583 len
+= strlen (lto_canonical
) + 1;
3587 if (cl_options
[options
[i
].opt_index
].flags
3588 & CL_NO_DWARF_RECORD
)
3590 gcc_checking_assert (options
[i
].canonical_option
[0][0] == '-');
3591 switch (options
[i
].canonical_option
[0][1])
3598 if (strncmp (options
[i
].canonical_option
[0] + 2,
3605 switches
.safe_push (options
[i
].orig_option_with_args_text
);
3606 len
+= strlen (options
[i
].orig_option_with_args_text
) + 1;
3610 options_string
= XNEWVEC (char, len
+ 1);
3611 tail
= options_string
;
3614 FOR_EACH_VEC_ELT (switches
, i
, p
)
3617 memcpy (tail
, p
, len
);
3619 if (i
!= switches
.length () - 1)
3627 return options_string
;
3630 /* Return a heap allocated producer string including command line options. */
3633 gen_producer_string (const char *language_string
, cl_decoded_option
*options
,
3634 unsigned int options_count
)
3636 char *cmdline
= gen_command_line_string (options
, options_count
);
3637 char *combined
= concat (language_string
, " ", version_string
, " ",
3645 namespace selftest
{
3647 /* Verify that get_option_html_page works as expected. */
3650 test_get_option_html_page ()
3652 ASSERT_STREQ (get_option_html_page (OPT_Wcpp
), "gcc/Warning-Options.html");
3653 ASSERT_STREQ (get_option_html_page (OPT_Wanalyzer_double_free
),
3654 "gcc/Static-Analyzer-Options.html");
3656 ASSERT_STREQ (get_option_html_page (OPT_Wline_truncation
),
3657 "gfortran/Error-and-Warning-Options.html");
3661 /* Run all of the selftests within this file. */
3666 test_get_option_html_page ();
3669 } // namespace selftest
3671 #endif /* #if CHECKING_P */