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 },
585 /* -O1 (and not -Og) optimizations. */
586 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fbranch_count_reg
, NULL
, 1 },
588 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fdelayed_branch
, NULL
, 1 },
590 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fdse
, NULL
, 1 },
591 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion
, NULL
, 1 },
592 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion2
, NULL
, 1 },
593 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_finline_functions_called_once
, NULL
, 1 },
594 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_invariants
, NULL
, 1 },
595 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_stores
, NULL
, 1 },
596 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fssa_phiopt
, NULL
, 1 },
597 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fipa_modref
, NULL
, 1 },
598 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_bit_ccp
, NULL
, 1 },
599 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_dse
, NULL
, 1 },
600 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_pta
, NULL
, 1 },
601 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_sra
, NULL
, 1 },
603 /* -O2 and -Os optimizations. */
604 { OPT_LEVELS_2_PLUS
, OPT_fcaller_saves
, NULL
, 1 },
605 { OPT_LEVELS_2_PLUS
, OPT_fcode_hoisting
, NULL
, 1 },
606 { OPT_LEVELS_2_PLUS
, OPT_fcrossjumping
, NULL
, 1 },
607 { OPT_LEVELS_2_PLUS
, OPT_fcse_follow_jumps
, NULL
, 1 },
608 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize
, NULL
, 1 },
609 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize_speculatively
, NULL
, 1 },
610 { OPT_LEVELS_2_PLUS
, OPT_fexpensive_optimizations
, NULL
, 1 },
611 { OPT_LEVELS_2_PLUS
, OPT_fgcse
, NULL
, 1 },
612 { OPT_LEVELS_2_PLUS
, OPT_fhoist_adjacent_loads
, NULL
, 1 },
613 { OPT_LEVELS_2_PLUS
, OPT_findirect_inlining
, NULL
, 1 },
614 { OPT_LEVELS_2_PLUS
, OPT_finline_small_functions
, NULL
, 1 },
615 { OPT_LEVELS_2_PLUS
, OPT_fipa_bit_cp
, NULL
, 1 },
616 { OPT_LEVELS_2_PLUS
, OPT_fipa_cp
, NULL
, 1 },
617 { OPT_LEVELS_2_PLUS
, OPT_fipa_icf
, NULL
, 1 },
618 { OPT_LEVELS_2_PLUS
, OPT_fipa_ra
, NULL
, 1 },
619 { OPT_LEVELS_2_PLUS
, OPT_fipa_sra
, NULL
, 1 },
620 { OPT_LEVELS_2_PLUS
, OPT_fipa_vrp
, NULL
, 1 },
621 { OPT_LEVELS_2_PLUS
, OPT_fisolate_erroneous_paths_dereference
, NULL
, 1 },
622 { OPT_LEVELS_2_PLUS
, OPT_flra_remat
, NULL
, 1 },
623 { OPT_LEVELS_2_PLUS
, OPT_foptimize_sibling_calls
, NULL
, 1 },
624 { OPT_LEVELS_2_PLUS
, OPT_fpartial_inlining
, NULL
, 1 },
625 { OPT_LEVELS_2_PLUS
, OPT_fpeephole2
, NULL
, 1 },
626 { OPT_LEVELS_2_PLUS
, OPT_freorder_functions
, NULL
, 1 },
627 { OPT_LEVELS_2_PLUS
, OPT_frerun_cse_after_loop
, NULL
, 1 },
628 #ifdef INSN_SCHEDULING
629 { OPT_LEVELS_2_PLUS
, OPT_fschedule_insns2
, NULL
, 1 },
631 { OPT_LEVELS_2_PLUS
, OPT_fstrict_aliasing
, NULL
, 1 },
632 { OPT_LEVELS_2_PLUS
, OPT_fstore_merging
, NULL
, 1 },
633 { OPT_LEVELS_2_PLUS
, OPT_ftree_pre
, NULL
, 1 },
634 { OPT_LEVELS_2_PLUS
, OPT_ftree_switch_conversion
, NULL
, 1 },
635 { OPT_LEVELS_2_PLUS
, OPT_ftree_tail_merge
, NULL
, 1 },
636 { OPT_LEVELS_2_PLUS
, OPT_ftree_vrp
, NULL
, 1 },
637 { OPT_LEVELS_2_PLUS
, OPT_fvect_cost_model_
, NULL
,
638 VECT_COST_MODEL_VERY_CHEAP
},
639 { OPT_LEVELS_2_PLUS
, OPT_finline_functions
, NULL
, 1 },
640 { OPT_LEVELS_2_PLUS
, OPT_ftree_loop_distribute_patterns
, NULL
, 1 },
642 /* -O2 and above optimizations, but not -Os or -Og. */
643 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_functions
, NULL
, 1 },
644 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_jumps
, NULL
, 1 },
645 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_labels
, NULL
, 1 },
646 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_loops
, NULL
, 1 },
647 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_foptimize_strlen
, NULL
, 1 },
648 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_freorder_blocks_algorithm_
, NULL
,
649 REORDER_BLOCKS_ALGORITHM_STC
},
650 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_ftree_loop_vectorize
, NULL
, 1 },
651 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_ftree_slp_vectorize
, NULL
, 1 },
652 #ifdef INSN_SCHEDULING
653 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
654 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_fschedule_insns
, NULL
, 1 },
657 /* -O3 and -Os optimizations. */
659 /* -O3 optimizations. */
660 { OPT_LEVELS_3_PLUS
, OPT_fgcse_after_reload
, NULL
, 1 },
661 { OPT_LEVELS_3_PLUS
, OPT_fipa_cp_clone
, NULL
, 1 },
662 { OPT_LEVELS_3_PLUS
, OPT_floop_interchange
, NULL
, 1 },
663 { OPT_LEVELS_3_PLUS
, OPT_floop_unroll_and_jam
, NULL
, 1 },
664 { OPT_LEVELS_3_PLUS
, OPT_fpeel_loops
, NULL
, 1 },
665 { OPT_LEVELS_3_PLUS
, OPT_fpredictive_commoning
, NULL
, 1 },
666 { OPT_LEVELS_3_PLUS
, OPT_fsplit_loops
, NULL
, 1 },
667 { OPT_LEVELS_3_PLUS
, OPT_fsplit_paths
, NULL
, 1 },
668 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribution
, NULL
, 1 },
669 { OPT_LEVELS_3_PLUS
, OPT_ftree_partial_pre
, NULL
, 1 },
670 { OPT_LEVELS_3_PLUS
, OPT_funswitch_loops
, NULL
, 1 },
671 { OPT_LEVELS_3_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_DYNAMIC
},
672 { OPT_LEVELS_3_PLUS
, OPT_fversion_loops_for_strides
, NULL
, 1 },
674 /* -O3 parameters. */
675 { OPT_LEVELS_3_PLUS
, OPT__param_max_inline_insns_auto_
, NULL
, 30 },
676 { OPT_LEVELS_3_PLUS
, OPT__param_early_inlining_insns_
, NULL
, 14 },
677 { OPT_LEVELS_3_PLUS
, OPT__param_inline_heuristics_hint_percent_
, NULL
, 600 },
678 { OPT_LEVELS_3_PLUS
, OPT__param_inline_min_speedup_
, NULL
, 15 },
679 { OPT_LEVELS_3_PLUS
, OPT__param_max_inline_insns_single_
, NULL
, 200 },
681 /* -Ofast adds optimizations to -O3. */
682 { OPT_LEVELS_FAST
, OPT_ffast_math
, NULL
, 1 },
683 { OPT_LEVELS_FAST
, OPT_fallow_store_data_races
, NULL
, 1 },
685 { OPT_LEVELS_NONE
, 0, NULL
, 0 }
688 /* Default the options in OPTS and OPTS_SET based on the optimization
689 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
691 default_options_optimization (struct gcc_options
*opts
,
692 struct gcc_options
*opts_set
,
693 struct cl_decoded_option
*decoded_options
,
694 unsigned int decoded_options_count
,
696 unsigned int lang_mask
,
697 const struct cl_option_handlers
*handlers
,
698 diagnostic_context
*dc
)
702 bool openacc_mode
= false;
704 /* Scan to see what optimization level has been specified. That will
705 determine the default value of many flags. */
706 for (i
= 1; i
< decoded_options_count
; i
++)
708 struct cl_decoded_option
*opt
= &decoded_options
[i
];
709 switch (opt
->opt_index
)
712 if (*opt
->arg
== '\0')
714 opts
->x_optimize
= 1;
715 opts
->x_optimize_size
= 0;
716 opts
->x_optimize_fast
= 0;
717 opts
->x_optimize_debug
= 0;
721 const int optimize_val
= integral_argument (opt
->arg
);
722 if (optimize_val
== -1)
723 error_at (loc
, "argument to %<-O%> should be a non-negative "
724 "integer, %<g%>, %<s%> or %<fast%>");
727 opts
->x_optimize
= optimize_val
;
728 if ((unsigned int) opts
->x_optimize
> 255)
729 opts
->x_optimize
= 255;
730 opts
->x_optimize_size
= 0;
731 opts
->x_optimize_fast
= 0;
732 opts
->x_optimize_debug
= 0;
738 opts
->x_optimize_size
= 1;
740 /* Optimizing for size forces optimize to be 2. */
741 opts
->x_optimize
= 2;
742 opts
->x_optimize_fast
= 0;
743 opts
->x_optimize_debug
= 0;
747 /* -Ofast only adds flags to -O3. */
748 opts
->x_optimize_size
= 0;
749 opts
->x_optimize
= 3;
750 opts
->x_optimize_fast
= 1;
751 opts
->x_optimize_debug
= 0;
755 /* -Og selects optimization level 1. */
756 opts
->x_optimize_size
= 0;
757 opts
->x_optimize
= 1;
758 opts
->x_optimize_fast
= 0;
759 opts
->x_optimize_debug
= 1;
768 /* Ignore other options in this prescan. */
773 maybe_default_options (opts
, opts_set
, default_options_table
,
774 opts
->x_optimize
, opts
->x_optimize_size
,
775 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
776 lang_mask
, handlers
, loc
, dc
);
778 /* -O2 param settings. */
779 opt2
= (opts
->x_optimize
>= 2);
782 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_pta
, true);
784 /* Track fields in field-sensitive alias analysis. */
786 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_fields_for_field_sensitive
,
789 if (opts
->x_optimize_size
)
790 /* We want to crossjump as much as possible. */
791 SET_OPTION_IF_UNSET (opts
, opts_set
, param_min_crossjump_insns
, 1);
793 /* Restrict the amount of work combine does at -Og while retaining
794 most of its useful transforms. */
795 if (opts
->x_optimize_debug
)
796 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_combine_insns
, 2);
798 /* Allow default optimizations to be specified on a per-machine basis. */
799 maybe_default_options (opts
, opts_set
,
800 targetm_common
.option_optimization_table
,
801 opts
->x_optimize
, opts
->x_optimize_size
,
802 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
803 lang_mask
, handlers
, loc
, dc
);
806 /* Control IPA optimizations based on different live patching LEVEL. */
808 control_options_for_live_patching (struct gcc_options
*opts
,
809 struct gcc_options
*opts_set
,
810 enum live_patching_level level
,
813 gcc_assert (level
> LIVE_PATCHING_NONE
);
817 case LIVE_PATCHING_INLINE_ONLY_STATIC
:
818 #define LIVE_PATCHING_OPTION "-flive-patching=inline-only-static"
819 if (opts_set
->x_flag_ipa_cp_clone
&& opts
->x_flag_ipa_cp_clone
)
820 error_at (loc
, "%qs is incompatible with %qs",
821 "-fipa-cp-clone", LIVE_PATCHING_OPTION
);
823 opts
->x_flag_ipa_cp_clone
= 0;
825 if (opts_set
->x_flag_ipa_sra
&& opts
->x_flag_ipa_sra
)
826 error_at (loc
, "%qs is incompatible with %qs",
827 "-fipa-sra", LIVE_PATCHING_OPTION
);
829 opts
->x_flag_ipa_sra
= 0;
831 if (opts_set
->x_flag_partial_inlining
&& opts
->x_flag_partial_inlining
)
832 error_at (loc
, "%qs is incompatible with %qs",
833 "-fpartial-inlining", LIVE_PATCHING_OPTION
);
835 opts
->x_flag_partial_inlining
= 0;
837 if (opts_set
->x_flag_ipa_cp
&& opts
->x_flag_ipa_cp
)
838 error_at (loc
, "%qs is incompatible with %qs",
839 "-fipa-cp", LIVE_PATCHING_OPTION
);
841 opts
->x_flag_ipa_cp
= 0;
844 case LIVE_PATCHING_INLINE_CLONE
:
845 #undef LIVE_PATCHING_OPTION
846 #define LIVE_PATCHING_OPTION "-flive-patching=inline-only-static|inline-clone"
847 /* live patching should disable whole-program optimization. */
848 if (opts_set
->x_flag_whole_program
&& opts
->x_flag_whole_program
)
849 error_at (loc
, "%qs is incompatible with %qs",
850 "-fwhole-program", LIVE_PATCHING_OPTION
);
852 opts
->x_flag_whole_program
= 0;
854 /* visibility change should be excluded by !flag_whole_program
855 && !in_lto_p && !flag_ipa_cp_clone && !flag_ipa_sra
856 && !flag_partial_inlining. */
858 if (opts_set
->x_flag_ipa_pta
&& opts
->x_flag_ipa_pta
)
859 error_at (loc
, "%qs is incompatible with %qs",
860 "-fipa-pta", LIVE_PATCHING_OPTION
);
862 opts
->x_flag_ipa_pta
= 0;
864 if (opts_set
->x_flag_ipa_reference
&& opts
->x_flag_ipa_reference
)
865 error_at (loc
, "%qs is incompatible with %qs",
866 "-fipa-reference", LIVE_PATCHING_OPTION
);
868 opts
->x_flag_ipa_reference
= 0;
870 if (opts_set
->x_flag_ipa_ra
&& opts
->x_flag_ipa_ra
)
871 error_at (loc
, "%qs is incompatible with %qs",
872 "-fipa-ra", LIVE_PATCHING_OPTION
);
874 opts
->x_flag_ipa_ra
= 0;
876 if (opts_set
->x_flag_ipa_icf
&& opts
->x_flag_ipa_icf
)
877 error_at (loc
, "%qs is incompatible with %qs",
878 "-fipa-icf", LIVE_PATCHING_OPTION
);
880 opts
->x_flag_ipa_icf
= 0;
882 if (opts_set
->x_flag_ipa_icf_functions
&& opts
->x_flag_ipa_icf_functions
)
883 error_at (loc
, "%qs is incompatible with %qs",
884 "-fipa-icf-functions", LIVE_PATCHING_OPTION
);
886 opts
->x_flag_ipa_icf_functions
= 0;
888 if (opts_set
->x_flag_ipa_icf_variables
&& opts
->x_flag_ipa_icf_variables
)
889 error_at (loc
, "%qs is incompatible with %qs",
890 "-fipa-icf-variables", LIVE_PATCHING_OPTION
);
892 opts
->x_flag_ipa_icf_variables
= 0;
894 if (opts_set
->x_flag_ipa_bit_cp
&& opts
->x_flag_ipa_bit_cp
)
895 error_at (loc
, "%qs is incompatible with %qs",
896 "-fipa-bit-cp", LIVE_PATCHING_OPTION
);
898 opts
->x_flag_ipa_bit_cp
= 0;
900 if (opts_set
->x_flag_ipa_vrp
&& opts
->x_flag_ipa_vrp
)
901 error_at (loc
, "%qs is incompatible with %qs",
902 "-fipa-vrp", LIVE_PATCHING_OPTION
);
904 opts
->x_flag_ipa_vrp
= 0;
906 if (opts_set
->x_flag_ipa_pure_const
&& opts
->x_flag_ipa_pure_const
)
907 error_at (loc
, "%qs is incompatible with %qs",
908 "-fipa-pure-const", LIVE_PATCHING_OPTION
);
910 opts
->x_flag_ipa_pure_const
= 0;
912 if (opts_set
->x_flag_ipa_modref
&& opts
->x_flag_ipa_modref
)
914 "%<-fipa-modref%> is incompatible with %qs",
915 LIVE_PATCHING_OPTION
);
917 opts
->x_flag_ipa_modref
= 0;
919 /* FIXME: disable unreachable code removal. */
921 /* discovery of functions/variables with no address taken. */
922 if (opts_set
->x_flag_ipa_reference_addressable
923 && opts
->x_flag_ipa_reference_addressable
)
924 error_at (loc
, "%qs is incompatible with %qs",
925 "-fipa-reference-addressable", LIVE_PATCHING_OPTION
);
927 opts
->x_flag_ipa_reference_addressable
= 0;
929 /* ipa stack alignment propagation. */
930 if (opts_set
->x_flag_ipa_stack_alignment
931 && opts
->x_flag_ipa_stack_alignment
)
932 error_at (loc
, "%qs is incompatible with %qs",
933 "-fipa-stack-alignment", LIVE_PATCHING_OPTION
);
935 opts
->x_flag_ipa_stack_alignment
= 0;
941 #undef LIVE_PATCHING_OPTION
944 /* --help option argument if set. */
945 vec
<const char *> help_option_arguments
;
947 /* Return the string name describing a sanitizer argument which has been
948 provided on the command line and has set this particular flag. */
950 find_sanitizer_argument (struct gcc_options
*opts
, unsigned int flags
)
952 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
954 /* Need to find the sanitizer_opts element which:
955 a) Could have set the flags requested.
956 b) Has been set on the command line.
958 Can have (a) without (b) if the flag requested is e.g.
959 SANITIZE_ADDRESS, since both -fsanitize=address and
960 -fsanitize=kernel-address set this flag.
962 Can have (b) without (a) by requesting more than one sanitizer on the
964 if ((sanitizer_opts
[i
].flag
& opts
->x_flag_sanitize
)
965 != sanitizer_opts
[i
].flag
)
967 if ((sanitizer_opts
[i
].flag
& flags
) != flags
)
969 return sanitizer_opts
[i
].name
;
975 /* Report an error to the user about sanitizer options they have requested
976 which have set conflicting flags.
978 LEFT and RIGHT indicate sanitizer flags which conflict with each other, this
979 function reports an error if both have been set in OPTS->x_flag_sanitize and
980 ensures the error identifies the requested command line options that have
983 report_conflicting_sanitizer_options (struct gcc_options
*opts
, location_t loc
,
984 unsigned int left
, unsigned int right
)
986 unsigned int left_seen
= (opts
->x_flag_sanitize
& left
);
987 unsigned int right_seen
= (opts
->x_flag_sanitize
& right
);
988 if (left_seen
&& right_seen
)
990 const char* left_arg
= find_sanitizer_argument (opts
, left_seen
);
991 const char* right_arg
= find_sanitizer_argument (opts
, right_seen
);
992 gcc_assert (left_arg
&& right_arg
);
994 "%<-fsanitize=%s%> is incompatible with %<-fsanitize=%s%>",
995 left_arg
, right_arg
);
999 /* After all options at LOC have been read into OPTS and OPTS_SET,
1000 finalize settings of those options and diagnose incompatible
1003 finish_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
1006 enum unwind_info_type ui_except
;
1008 if (opts
->x_dump_base_name
1009 && ! opts
->x_dump_base_name_prefixed
)
1011 const char *sep
= opts
->x_dump_base_name
;
1014 if (IS_DIR_SEPARATOR (*sep
))
1018 /* If dump_base_path contains subdirectories, don't prepend
1020 else if (opts
->x_dump_dir_name
)
1021 /* We have a DUMP_DIR_NAME, prepend that. */
1022 opts
->x_dump_base_name
= opts_concat (opts
->x_dump_dir_name
,
1023 opts
->x_dump_base_name
, NULL
);
1025 /* It is definitely prefixed now. */
1026 opts
->x_dump_base_name_prefixed
= true;
1029 /* Handle related options for unit-at-a-time, toplevel-reorder, and
1031 if (!opts
->x_flag_unit_at_a_time
)
1033 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
1034 error_at (loc
, "section anchors must be disabled when unit-at-a-time "
1036 opts
->x_flag_section_anchors
= 0;
1037 if (opts
->x_flag_toplevel_reorder
== 1)
1038 error_at (loc
, "toplevel reorder must be disabled when unit-at-a-time "
1040 opts
->x_flag_toplevel_reorder
= 0;
1043 /* -fself-test depends on the state of the compiler prior to
1044 compiling anything. Ideally it should be run on an empty source
1045 file. However, in case we get run with actual source, assume
1046 -fsyntax-only which will inhibit any compiler initialization
1047 which may confuse the self tests. */
1048 if (opts
->x_flag_self_test
)
1049 opts
->x_flag_syntax_only
= 1;
1051 if (opts
->x_flag_tm
&& opts
->x_flag_non_call_exceptions
)
1052 sorry ("transactional memory is not supported with non-call exceptions");
1054 /* Unless the user has asked for section anchors, we disable toplevel
1055 reordering at -O0 to disable transformations that might be surprising
1056 to end users and to get -fno-toplevel-reorder tested. */
1057 if (!opts
->x_optimize
1058 && opts
->x_flag_toplevel_reorder
== 2
1059 && !(opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
))
1061 opts
->x_flag_toplevel_reorder
= 0;
1062 opts
->x_flag_section_anchors
= 0;
1064 if (!opts
->x_flag_toplevel_reorder
)
1066 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
1067 error_at (loc
, "section anchors must be disabled when toplevel reorder"
1069 opts
->x_flag_section_anchors
= 0;
1072 if (!opts
->x_flag_opts_finished
)
1074 /* We initialize opts->x_flag_pie to -1 so that targets can set a
1076 if (opts
->x_flag_pie
== -1)
1078 /* We initialize opts->x_flag_pic to -1 so that we can tell if
1079 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
1080 if (opts
->x_flag_pic
== -1)
1081 opts
->x_flag_pie
= DEFAULT_FLAG_PIE
;
1083 opts
->x_flag_pie
= 0;
1085 /* If -fPIE or -fpie is used, turn on PIC. */
1086 if (opts
->x_flag_pie
)
1087 opts
->x_flag_pic
= opts
->x_flag_pie
;
1088 else if (opts
->x_flag_pic
== -1)
1089 opts
->x_flag_pic
= 0;
1090 if (opts
->x_flag_pic
&& !opts
->x_flag_pie
)
1091 opts
->x_flag_shlib
= 1;
1092 opts
->x_flag_opts_finished
= true;
1095 /* We initialize opts->x_flag_stack_protect to -1 so that targets
1096 can set a default value. */
1097 if (opts
->x_flag_stack_protect
== -1)
1098 opts
->x_flag_stack_protect
= DEFAULT_FLAG_SSP
;
1100 if (opts
->x_optimize
== 0)
1102 /* Inlining does not work if not optimizing,
1103 so force it not to be done. */
1104 opts
->x_warn_inline
= 0;
1105 opts
->x_flag_no_inline
= 1;
1108 /* The optimization to partition hot and cold basic blocks into separate
1109 sections of the .o and executable files does not work (currently)
1110 with exception handling. This is because there is no support for
1111 generating unwind info. If opts->x_flag_exceptions is turned on
1112 we need to turn off the partitioning optimization. */
1114 ui_except
= targetm_common
.except_unwind_info (opts
);
1116 if (opts
->x_flag_exceptions
1117 && opts
->x_flag_reorder_blocks_and_partition
1118 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1120 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1122 "%<-freorder-blocks-and-partition%> does not work "
1123 "with exceptions on this architecture");
1124 opts
->x_flag_reorder_blocks_and_partition
= 0;
1125 opts
->x_flag_reorder_blocks
= 1;
1128 /* If user requested unwind info, then turn off the partitioning
1131 if (opts
->x_flag_unwind_tables
1132 && !targetm_common
.unwind_tables_default
1133 && opts
->x_flag_reorder_blocks_and_partition
1134 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1136 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1138 "%<-freorder-blocks-and-partition%> does not support "
1139 "unwind info on this architecture");
1140 opts
->x_flag_reorder_blocks_and_partition
= 0;
1141 opts
->x_flag_reorder_blocks
= 1;
1144 /* If the target requested unwind info, then turn off the partitioning
1145 optimization with a different message. Likewise, if the target does not
1146 support named sections. */
1148 if (opts
->x_flag_reorder_blocks_and_partition
1149 && (!targetm_common
.have_named_sections
1150 || (opts
->x_flag_unwind_tables
1151 && targetm_common
.unwind_tables_default
1152 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
1154 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1156 "%<-freorder-blocks-and-partition%> does not work "
1157 "on this architecture");
1158 opts
->x_flag_reorder_blocks_and_partition
= 0;
1159 opts
->x_flag_reorder_blocks
= 1;
1163 /* Pipelining of outer loops is only possible when general pipelining
1164 capabilities are requested. */
1165 if (!opts
->x_flag_sel_sched_pipelining
)
1166 opts
->x_flag_sel_sched_pipelining_outer_loops
= 0;
1168 if (opts
->x_flag_conserve_stack
)
1170 SET_OPTION_IF_UNSET (opts
, opts_set
, param_large_stack_frame
, 100);
1171 SET_OPTION_IF_UNSET (opts
, opts_set
, param_stack_frame_growth
, 40);
1174 if (opts
->x_flag_lto
)
1177 opts
->x_flag_generate_lto
= 1;
1179 /* When generating IL, do not operate in whole-program mode.
1180 Otherwise, symbols will be privatized too early, causing link
1182 opts
->x_flag_whole_program
= 0;
1184 error_at (loc
, "LTO support has not been enabled in this configuration");
1186 if (!opts
->x_flag_fat_lto_objects
1187 && (!HAVE_LTO_PLUGIN
1188 || (opts_set
->x_flag_use_linker_plugin
1189 && !opts
->x_flag_use_linker_plugin
)))
1191 if (opts_set
->x_flag_fat_lto_objects
)
1192 error_at (loc
, "%<-fno-fat-lto-objects%> are supported only with "
1194 opts
->x_flag_fat_lto_objects
= 1;
1197 /* -gsplit-dwarf isn't compatible with LTO, see PR88389. */
1198 if (opts
->x_dwarf_split_debug_info
)
1200 inform (loc
, "%<-gsplit-dwarf%> is not supported with LTO,"
1202 opts
->x_dwarf_split_debug_info
= 0;
1206 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
1207 default value if they choose based on other options. */
1208 if (opts
->x_flag_split_stack
== -1)
1209 opts
->x_flag_split_stack
= 0;
1210 else if (opts
->x_flag_split_stack
)
1212 if (!targetm_common
.supports_split_stack (true, opts
))
1214 error_at (loc
, "%<-fsplit-stack%> is not supported by "
1215 "this compiler configuration");
1216 opts
->x_flag_split_stack
= 0;
1220 /* If stack splitting is turned on, and the user did not explicitly
1221 request function partitioning, turn off partitioning, as it
1222 confuses the linker when trying to handle partitioned split-stack
1223 code that calls a non-split-stack functions. But if partitioning
1224 was turned on explicitly just hope for the best. */
1225 if (opts
->x_flag_split_stack
1226 && opts
->x_flag_reorder_blocks_and_partition
)
1227 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_reorder_blocks_and_partition
, 0);
1229 if (opts
->x_flag_reorder_blocks_and_partition
)
1230 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_reorder_functions
, 1);
1232 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
1233 if (opts
->x_dwarf_split_debug_info
)
1234 opts
->x_debug_generate_pub_sections
= 2;
1236 if ((opts
->x_flag_sanitize
1237 & (SANITIZE_USER_ADDRESS
| SANITIZE_KERNEL_ADDRESS
)) == 0)
1239 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_COMPARE
)
1241 "%<-fsanitize=pointer-compare%> must be combined with "
1242 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1243 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_SUBTRACT
)
1245 "%<-fsanitize=pointer-subtract%> must be combined with "
1246 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1249 /* Address sanitizers conflict with the thread sanitizer. */
1250 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_THREAD
,
1251 SANITIZE_ADDRESS
| SANITIZE_HWADDRESS
);
1252 /* The leak sanitizer conflicts with the thread sanitizer. */
1253 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_LEAK
,
1256 /* No combination of HWASAN and ASAN work together. */
1257 report_conflicting_sanitizer_options (opts
, loc
,
1258 SANITIZE_HWADDRESS
, SANITIZE_ADDRESS
);
1260 /* The userspace and kernel address sanitizers conflict with each other. */
1261 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_USER_HWADDRESS
,
1262 SANITIZE_KERNEL_HWADDRESS
);
1263 report_conflicting_sanitizer_options (opts
, loc
, SANITIZE_USER_ADDRESS
,
1264 SANITIZE_KERNEL_ADDRESS
);
1266 /* Check error recovery for -fsanitize-recover option. */
1267 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1268 if ((opts
->x_flag_sanitize_recover
& sanitizer_opts
[i
].flag
)
1269 && !sanitizer_opts
[i
].can_recover
)
1270 error_at (loc
, "%<-fsanitize-recover=%s%> is not supported",
1271 sanitizer_opts
[i
].name
);
1273 /* When instrumenting the pointers, we don't want to remove
1274 the null pointer checks. */
1275 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
1276 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
1277 opts
->x_flag_delete_null_pointer_checks
= 0;
1279 /* Aggressive compiler optimizations may cause false negatives. */
1280 if (opts
->x_flag_sanitize
& ~(SANITIZE_LEAK
| SANITIZE_UNREACHABLE
))
1281 opts
->x_flag_aggressive_loop_optimizations
= 0;
1283 /* Enable -fsanitize-address-use-after-scope if either address sanitizer is
1285 if (opts
->x_flag_sanitize
1286 & (SANITIZE_USER_ADDRESS
| SANITIZE_USER_HWADDRESS
))
1287 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_sanitize_address_use_after_scope
,
1290 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1292 if (opts
->x_flag_sanitize_address_use_after_scope
)
1294 if (opts
->x_flag_stack_reuse
!= SR_NONE
1295 && opts_set
->x_flag_stack_reuse
!= SR_NONE
)
1297 "%<-fsanitize-address-use-after-scope%> requires "
1298 "%<-fstack-reuse=none%> option");
1300 opts
->x_flag_stack_reuse
= SR_NONE
;
1303 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
) && opts
->x_flag_tm
)
1304 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1306 if ((opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) && opts
->x_flag_tm
)
1307 sorry ("transactional memory is not supported with "
1308 "%<-fsanitize=kernel-address%>");
1310 /* Currently live patching is not support for LTO. */
1311 if (opts
->x_flag_live_patching
&& opts
->x_flag_lto
)
1312 sorry ("live patching is not supported with LTO");
1314 /* Currently vtable verification is not supported for LTO */
1315 if (opts
->x_flag_vtable_verify
&& opts
->x_flag_lto
)
1316 sorry ("vtable verification is not supported with LTO");
1318 /* Control IPA optimizations based on different -flive-patching level. */
1319 if (opts
->x_flag_live_patching
)
1320 control_options_for_live_patching (opts
, opts_set
,
1321 opts
->x_flag_live_patching
,
1324 /* Allow cunroll to grow size accordingly. */
1325 if (!opts_set
->x_flag_cunroll_grow_size
)
1326 opts
->x_flag_cunroll_grow_size
1327 = (opts
->x_flag_unroll_loops
1328 || opts
->x_flag_peel_loops
1329 || opts
->x_optimize
>= 3);
1331 /* With -fcx-limited-range, we do cheap and quick complex arithmetic. */
1332 if (opts
->x_flag_cx_limited_range
)
1333 opts
->x_flag_complex_method
= 0;
1334 else if (opts_set
->x_flag_cx_limited_range
)
1335 opts
->x_flag_complex_method
= opts
->x_flag_default_complex_method
;
1337 /* With -fcx-fortran-rules, we do something in-between cheap and C99. */
1338 if (opts
->x_flag_cx_fortran_rules
)
1339 opts
->x_flag_complex_method
= 1;
1340 else if (opts_set
->x_flag_cx_fortran_rules
)
1341 opts
->x_flag_complex_method
= opts
->x_flag_default_complex_method
;
1343 /* Use -fvect-cost-model=cheap instead of -fvect-cost-mode=very-cheap
1344 by default with explicit -ftree-{loop,slp}-vectorize. */
1345 if (opts
->x_optimize
== 2
1346 && (opts_set
->x_flag_tree_loop_vectorize
1347 || opts_set
->x_flag_tree_vectorize
))
1348 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_vect_cost_model
,
1349 VECT_COST_MODEL_CHEAP
);
1353 #define LEFT_COLUMN 27
1355 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1356 followed by word-wrapped HELP in a second column. */
1358 wrap_help (const char *help
,
1360 unsigned int item_width
,
1361 unsigned int columns
)
1363 unsigned int col_width
= LEFT_COLUMN
;
1364 unsigned int remaining
, room
, len
;
1366 remaining
= strlen (help
);
1370 room
= columns
- 3 - MAX (col_width
, item_width
);
1379 for (i
= 0; help
[i
]; i
++)
1381 if (i
>= room
&& len
!= remaining
)
1385 else if ((help
[i
] == '-' || help
[i
] == '/')
1386 && help
[i
+ 1] != ' '
1387 && i
> 0 && ISALPHA (help
[i
- 1]))
1392 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1394 while (help
[len
] == ' ')
1402 /* Data structure used to print list of valid option values. */
1404 class option_help_tuple
1407 option_help_tuple (int code
, vec
<const char *> values
):
1408 m_code (code
), m_values (values
)
1411 /* Code of an option. */
1414 /* List of possible values. */
1415 vec
<const char *> m_values
;
1418 /* Print help for a specific front-end, etc. */
1420 print_filtered_help (unsigned int include_flags
,
1421 unsigned int exclude_flags
,
1422 unsigned int any_flags
,
1423 unsigned int columns
,
1424 struct gcc_options
*opts
,
1425 unsigned int lang_mask
)
1430 bool displayed
= false;
1433 if (!opts
->x_help_printed
)
1434 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1436 if (!opts
->x_help_enum_printed
)
1437 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1439 auto_vec
<option_help_tuple
> help_tuples
;
1441 for (i
= 0; i
< cl_options_count
; i
++)
1443 const struct cl_option
*option
= cl_options
+ i
;
1448 if (include_flags
== 0
1449 || ((option
->flags
& include_flags
) != include_flags
))
1451 if ((option
->flags
& any_flags
) == 0)
1455 /* Skip unwanted switches. */
1456 if ((option
->flags
& exclude_flags
) != 0)
1459 /* The driver currently prints its own help text. */
1460 if ((option
->flags
& CL_DRIVER
) != 0
1461 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1462 | CL_COMMON
| CL_TARGET
)) == 0)
1465 /* If an option contains a language specification,
1466 exclude it from common unless all languages are present. */
1467 if ((include_flags
& CL_COMMON
)
1468 && !(option
->flags
& CL_DRIVER
)
1469 && (option
->flags
& CL_LANG_ALL
)
1470 && (option
->flags
& CL_LANG_ALL
) != CL_LANG_ALL
)
1474 /* Skip switches that have already been printed. */
1475 if (opts
->x_help_printed
[i
])
1478 opts
->x_help_printed
[i
] = true;
1480 help
= option
->help
;
1483 if (exclude_flags
& CL_UNDOCUMENTED
)
1486 help
= undocumented_msg
;
1489 /* Get the translation. */
1492 if (option
->alias_target
< N_OPTS
1493 && cl_options
[option
->alias_target
].help
)
1495 const struct cl_option
*target
= cl_options
+ option
->alias_target
;
1496 if (option
->help
== NULL
)
1498 /* The option is undocumented but is an alias for an option that
1499 is documented. If the option has alias arguments, then its
1500 purpose is to provide certain arguments to the other option, so
1501 inform the reader of this. Otherwise, point the reader to the
1502 other option in preference to the former. */
1504 if (option
->alias_arg
)
1506 if (option
->neg_alias_arg
)
1507 snprintf (new_help
, sizeof new_help
,
1508 _("Same as %s%s (or, in negated form, %s%s)."),
1509 target
->opt_text
, option
->alias_arg
,
1510 target
->opt_text
, option
->neg_alias_arg
);
1512 snprintf (new_help
, sizeof new_help
,
1514 target
->opt_text
, option
->alias_arg
);
1517 snprintf (new_help
, sizeof new_help
,
1523 /* For documented options with aliases, mention the aliased
1524 option's name for reference. */
1525 snprintf (new_help
, sizeof new_help
,
1526 _("%s Same as %s."),
1527 help
, cl_options
[option
->alias_target
].opt_text
);
1533 if (option
->warn_message
)
1535 /* Mention that the use of the option will trigger a warning. */
1536 if (help
== new_help
)
1537 snprintf (new_help
+ strlen (new_help
),
1538 sizeof new_help
- strlen (new_help
),
1539 " %s", _(use_diagnosed_msg
));
1541 snprintf (new_help
, sizeof new_help
,
1542 "%s %s", help
, _(use_diagnosed_msg
));
1547 /* Find the gap between the name of the
1548 option and its descriptive text. */
1549 tab
= strchr (help
, '\t');
1558 opt
= option
->opt_text
;
1562 /* With the -Q option enabled we change the descriptive text associated
1563 with an option to be an indication of its current setting. */
1564 if (!opts
->x_quiet_flag
)
1566 void *flag_var
= option_flag_var (i
, opts
);
1568 if (len
< (LEFT_COLUMN
+ 2))
1569 strcpy (new_help
, "\t\t");
1571 strcpy (new_help
, "\t");
1573 /* Set to print whether the option is enabled or disabled,
1574 or, if it's an alias for another option, the name of
1575 the aliased option. */
1576 bool print_state
= false;
1578 if (flag_var
!= NULL
1579 && option
->var_type
!= CLVC_DEFER
)
1581 /* If OPTION is only available for a specific subset
1582 of languages other than this one, mention them. */
1583 bool avail_for_lang
= true;
1584 if (unsigned langset
= option
->flags
& CL_LANG_ALL
)
1586 if (!(langset
& lang_mask
))
1588 avail_for_lang
= false;
1589 strcat (new_help
, _("[available in "));
1590 for (unsigned i
= 0, n
= 0; (1U << i
) < CL_LANG_ALL
; ++i
)
1591 if (langset
& (1U << i
))
1594 strcat (new_help
, ", ");
1595 strcat (new_help
, lang_names
[i
]);
1597 strcat (new_help
, "]");
1600 if (!avail_for_lang
)
1601 ; /* Print nothing else if the option is not available
1602 in the current language. */
1603 else if (option
->flags
& CL_JOINED
)
1605 if (option
->var_type
== CLVC_STRING
)
1607 if (* (const char **) flag_var
!= NULL
)
1608 snprintf (new_help
+ strlen (new_help
),
1609 sizeof (new_help
) - strlen (new_help
),
1610 "%s", * (const char **) flag_var
);
1612 else if (option
->var_type
== CLVC_ENUM
)
1614 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1616 const char *arg
= NULL
;
1618 value
= e
->get (flag_var
);
1619 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1621 arg
= _("[default]");
1622 snprintf (new_help
+ strlen (new_help
),
1623 sizeof (new_help
) - strlen (new_help
),
1628 if (option
->cl_host_wide_int
)
1629 sprintf (new_help
+ strlen (new_help
),
1630 _("%llu bytes"), (unsigned long long)
1631 *(unsigned HOST_WIDE_INT
*) flag_var
);
1633 sprintf (new_help
+ strlen (new_help
),
1634 "%i", * (int *) flag_var
);
1641 /* When there is no argument, print the option state only
1642 if the option takes no argument. */
1643 print_state
= !(option
->flags
& CL_JOINED
);
1647 if (option
->alias_target
< N_OPTS
1648 && option
->alias_target
!= OPT_SPECIAL_warn_removed
1649 && option
->alias_target
!= OPT_SPECIAL_ignore
1650 && option
->alias_target
!= OPT_SPECIAL_input_file
1651 && option
->alias_target
!= OPT_SPECIAL_program_name
1652 && option
->alias_target
!= OPT_SPECIAL_unknown
)
1654 const struct cl_option
*target
1655 = &cl_options
[option
->alias_target
];
1656 sprintf (new_help
+ strlen (new_help
), "%s%s",
1658 option
->alias_arg
? option
->alias_arg
: "");
1660 else if (option
->alias_target
== OPT_SPECIAL_ignore
)
1661 strcat (new_help
, ("[ignored]"));
1664 /* Print the state for an on/off option. */
1665 int ena
= option_enabled (i
, lang_mask
, opts
);
1667 strcat (new_help
, _("[enabled]"));
1669 strcat (new_help
, _("[disabled]"));
1676 if (option
->range_max
!= -1)
1679 snprintf (b
, sizeof (b
), "<%d,%d>", option
->range_min
,
1681 opt
= concat (opt
, b
, NULL
);
1685 wrap_help (help
, opt
, len
, columns
);
1688 if (option
->var_type
== CLVC_ENUM
1689 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1690 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1693 vec
<const char *> option_values
1694 = targetm_common
.get_valid_option_values (i
, NULL
);
1695 if (!option_values
.is_empty ())
1696 help_tuples
.safe_push (option_help_tuple (i
, option_values
));
1702 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1705 printf (_(" No options with the desired characteristics were found\n"));
1710 /* PR 31349: Tell the user how to see all of the
1711 options supported by a specific front end. */
1712 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1713 if ((1U << i
) & langs
)
1714 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1715 lang_names
[i
], lang_names
[i
]);
1719 else if (! displayed
)
1720 printf (_(" All options with the desired characteristics have already been displayed\n"));
1724 /* Print details of enumerated option arguments, if those
1725 enumerations have help text headings provided. If no help text
1726 is provided, presume that the possible values are listed in the
1727 help text for the relevant options. */
1728 for (i
= 0; i
< cl_enums_count
; i
++)
1730 unsigned int j
, pos
;
1732 if (opts
->x_help_enum_printed
[i
] != 1)
1734 if (cl_enums
[i
].help
== NULL
)
1736 printf (" %s\n ", _(cl_enums
[i
].help
));
1738 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1740 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1742 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1744 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1754 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1759 opts
->x_help_enum_printed
[i
] = 2;
1762 for (unsigned i
= 0; i
< help_tuples
.length (); i
++)
1764 const struct cl_option
*option
= cl_options
+ help_tuples
[i
].m_code
;
1765 printf (_(" Known valid arguments for %s option:\n "),
1767 for (unsigned j
= 0; j
< help_tuples
[i
].m_values
.length (); j
++)
1768 printf (" %s", help_tuples
[i
].m_values
[j
]);
1773 /* Display help for a specified type of option.
1774 The options must have ALL of the INCLUDE_FLAGS set
1775 ANY of the flags in the ANY_FLAGS set
1776 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1777 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1779 print_specific_help (unsigned int include_flags
,
1780 unsigned int exclude_flags
,
1781 unsigned int any_flags
,
1782 struct gcc_options
*opts
,
1783 unsigned int lang_mask
)
1785 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1786 const char * description
= NULL
;
1787 const char * descrip_extra
= "";
1791 /* Sanity check: Make sure that we do not have more
1792 languages than we have bits available to enumerate them. */
1793 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1795 /* If we have not done so already, obtain
1796 the desired maximum width of the output. */
1797 if (opts
->x_help_columns
== 0)
1799 opts
->x_help_columns
= get_terminal_width ();
1800 if (opts
->x_help_columns
== INT_MAX
)
1801 /* Use a reasonable default. */
1802 opts
->x_help_columns
= 80;
1805 /* Decide upon the title for the options that we are going to display. */
1806 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1808 switch (flag
& include_flags
)
1815 description
= _("The following options are target specific");
1818 description
= _("The following options control compiler warning messages");
1820 case CL_OPTIMIZATION
:
1821 description
= _("The following options control optimizations");
1824 description
= _("The following options are language-independent");
1827 description
= _("The following options control parameters");
1830 if (i
>= cl_lang_count
)
1832 if (exclude_flags
& all_langs_mask
)
1833 description
= _("The following options are specific to just the language ");
1835 description
= _("The following options are supported by the language ");
1836 descrip_extra
= lang_names
[i
];
1841 if (description
== NULL
)
1845 if (include_flags
& CL_UNDOCUMENTED
)
1846 description
= _("The following options are not documented");
1847 else if (include_flags
& CL_SEPARATE
)
1848 description
= _("The following options take separate arguments");
1849 else if (include_flags
& CL_JOINED
)
1850 description
= _("The following options take joined arguments");
1853 internal_error ("unrecognized %<include_flags 0x%x%> passed "
1854 "to %<print_specific_help%>",
1861 if (any_flags
& all_langs_mask
)
1862 description
= _("The following options are language-related");
1864 description
= _("The following options are language-independent");
1868 printf ("%s%s:\n", description
, descrip_extra
);
1869 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
1870 opts
->x_help_columns
, opts
, lang_mask
);
1873 /* Enable FDO-related flags. */
1876 enable_fdo_optimizations (struct gcc_options
*opts
,
1877 struct gcc_options
*opts_set
,
1880 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_branch_probabilities
, value
);
1881 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
1882 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_loops
, value
);
1883 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_peel_loops
, value
);
1884 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tracer
, value
);
1885 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_value_profile_transformations
,
1887 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
1888 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp
, value
);
1891 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_cp_clone
, 1);
1892 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, 1);
1894 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_predictive_commoning
, value
);
1895 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_split_loops
, value
);
1896 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unswitch_loops
, value
);
1897 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_gcse_after_reload
, value
);
1898 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_vectorize
, value
);
1899 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_slp_vectorize
, value
);
1900 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_version_loops_for_strides
, value
);
1901 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_vect_cost_model
,
1902 VECT_COST_MODEL_DYNAMIC
);
1903 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribute_patterns
,
1905 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_loop_interchange
, value
);
1906 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_unroll_jam
, value
);
1907 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_tree_loop_distribution
, value
);
1910 /* -f{,no-}sanitize{,-recover}= suboptions. */
1911 const struct sanitizer_opts_s sanitizer_opts
[] =
1913 #define SANITIZER_OPT(name, flags, recover) \
1914 { #name, flags, sizeof #name - 1, recover }
1915 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true),
1916 SANITIZER_OPT (hwaddress
, (SANITIZE_HWADDRESS
| SANITIZE_USER_HWADDRESS
),
1918 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
1920 SANITIZER_OPT (kernel
-hwaddress
,
1921 (SANITIZE_HWADDRESS
| SANITIZE_KERNEL_HWADDRESS
),
1923 SANITIZER_OPT (pointer
-compare
, SANITIZE_POINTER_COMPARE
, true),
1924 SANITIZER_OPT (pointer
-subtract
, SANITIZE_POINTER_SUBTRACT
, true),
1925 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false),
1926 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false),
1927 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true),
1928 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true),
1929 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true),
1930 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true),
1931 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true),
1932 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false),
1933 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true),
1934 SANITIZER_OPT (return, SANITIZE_RETURN
, false),
1935 SANITIZER_OPT (null
, SANITIZE_NULL
, true),
1936 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true),
1937 SANITIZER_OPT (bool, SANITIZE_BOOL
, true),
1938 SANITIZER_OPT (enum, SANITIZE_ENUM
, true),
1939 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true),
1940 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true),
1941 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true),
1942 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true),
1943 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true),
1944 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true),
1945 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
1947 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true),
1948 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true),
1949 SANITIZER_OPT (pointer
-overflow
, SANITIZE_POINTER_OVERFLOW
, true),
1950 SANITIZER_OPT (builtin
, SANITIZE_BUILTIN
, true),
1951 SANITIZER_OPT (all
, ~0U, true),
1952 #undef SANITIZER_OPT
1953 { NULL
, 0U, 0UL, false }
1956 /* -fzero-call-used-regs= suboptions. */
1957 const struct zero_call_used_regs_opts_s zero_call_used_regs_opts
[] =
1959 #define ZERO_CALL_USED_REGS_OPT(name, flags) \
1961 ZERO_CALL_USED_REGS_OPT (skip
, zero_regs_flags::SKIP
),
1962 ZERO_CALL_USED_REGS_OPT (used
-gpr
-arg
, zero_regs_flags::USED_GPR_ARG
),
1963 ZERO_CALL_USED_REGS_OPT (used
-gpr
, zero_regs_flags::USED_GPR
),
1964 ZERO_CALL_USED_REGS_OPT (used
-arg
, zero_regs_flags::USED_ARG
),
1965 ZERO_CALL_USED_REGS_OPT (used
, zero_regs_flags::USED
),
1966 ZERO_CALL_USED_REGS_OPT (all
-gpr
-arg
, zero_regs_flags::ALL_GPR_ARG
),
1967 ZERO_CALL_USED_REGS_OPT (all
-gpr
, zero_regs_flags::ALL_GPR
),
1968 ZERO_CALL_USED_REGS_OPT (all
-arg
, zero_regs_flags::ALL_ARG
),
1969 ZERO_CALL_USED_REGS_OPT (all
, zero_regs_flags::ALL
),
1970 #undef ZERO_CALL_USED_REGS_OPT
1974 /* A struct for describing a run of chars within a string. */
1976 class string_fragment
1979 string_fragment (const char *start
, size_t len
)
1980 : m_start (start
), m_len (len
) {}
1982 const char *m_start
;
1986 /* Specialization of edit_distance_traits for string_fragment,
1987 for use by get_closest_sanitizer_option. */
1990 struct edit_distance_traits
<const string_fragment
&>
1992 static size_t get_length (const string_fragment
&fragment
)
1994 return fragment
.m_len
;
1997 static const char *get_string (const string_fragment
&fragment
)
1999 return fragment
.m_start
;
2003 /* Given ARG, an unrecognized sanitizer option, return the best
2004 matching sanitizer option, or NULL if there isn't one.
2005 OPTS is array of candidate sanitizer options.
2006 CODE is OPT_fsanitize_ or OPT_fsanitize_recover_.
2007 VALUE is non-zero for the regular form of the option, zero
2008 for the "no-" form (e.g. "-fno-sanitize-recover="). */
2011 get_closest_sanitizer_option (const string_fragment
&arg
,
2012 const struct sanitizer_opts_s
*opts
,
2013 enum opt_code code
, int value
)
2015 best_match
<const string_fragment
&, const char*> bm (arg
);
2016 for (int i
= 0; opts
[i
].name
!= NULL
; ++i
)
2018 /* -fsanitize=all is not valid, so don't offer it. */
2019 if (code
== OPT_fsanitize_
2020 && opts
[i
].flag
== ~0U
2024 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
2025 don't offer the non-recoverable options. */
2026 if (code
== OPT_fsanitize_recover_
2027 && !opts
[i
].can_recover
2031 bm
.consider (opts
[i
].name
);
2033 return bm
.get_best_meaningful_candidate ();
2036 /* Parse comma separated sanitizer suboptions from P for option SCODE,
2037 adjust previous FLAGS and return new ones. If COMPLAIN is false,
2038 don't issue diagnostics. */
2041 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
2042 unsigned int flags
, int value
, bool complain
)
2044 enum opt_code code
= (enum opt_code
) scode
;
2050 const char *comma
= strchr (p
, ',');
2062 /* Check to see if the string matches an option class name. */
2063 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
2064 if (len
== sanitizer_opts
[i
].len
2065 && memcmp (p
, sanitizer_opts
[i
].name
, len
) == 0)
2067 /* Handle both -fsanitize and -fno-sanitize cases. */
2068 if (value
&& sanitizer_opts
[i
].flag
== ~0U)
2070 if (code
== OPT_fsanitize_
)
2073 error_at (loc
, "%<-fsanitize=all%> option is not valid");
2076 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
2077 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2081 /* Do not enable -fsanitize-recover=unreachable and
2082 -fsanitize-recover=return if -fsanitize-recover=undefined
2084 if (code
== OPT_fsanitize_recover_
2085 && sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
2086 flags
|= (SANITIZE_UNDEFINED
2087 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
2089 flags
|= sanitizer_opts
[i
].flag
;
2092 flags
&= ~sanitizer_opts
[i
].flag
;
2097 if (! found
&& complain
)
2100 = get_closest_sanitizer_option (string_fragment (p
, len
),
2101 sanitizer_opts
, code
, value
);
2104 if (code
== OPT_fsanitize_recover_
)
2105 suffix
= "-recover";
2111 "unrecognized argument to %<-f%ssanitize%s=%> "
2112 "option: %q.*s; did you mean %qs?",
2114 suffix
, (int) len
, p
, hint
);
2117 "unrecognized argument to %<-f%ssanitize%s=%> option: "
2118 "%q.*s", value
? "" : "no-",
2119 suffix
, (int) len
, p
);
2129 /* Parse string values of no_sanitize attribute passed in VALUE.
2130 Values are separated with comma. */
2133 parse_no_sanitize_attribute (char *value
)
2135 unsigned int flags
= 0;
2137 char *q
= strtok (value
, ",");
2141 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
2142 if (strcmp (sanitizer_opts
[i
].name
, q
) == 0)
2144 flags
|= sanitizer_opts
[i
].flag
;
2145 if (sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
2146 flags
|= SANITIZE_UNDEFINED_NONDEFAULT
;
2150 if (sanitizer_opts
[i
].name
== NULL
)
2151 warning (OPT_Wattributes
,
2152 "%qs attribute directive ignored", q
);
2154 q
= strtok (NULL
, ",");
2160 /* Parse -fzero-call-used-regs suboptions from ARG, return the FLAGS. */
2163 parse_zero_call_used_regs_options (const char *arg
)
2165 unsigned int flags
= 0;
2167 /* Check to see if the string matches a sub-option name. */
2168 for (unsigned int i
= 0; zero_call_used_regs_opts
[i
].name
!= NULL
; ++i
)
2169 if (strcmp (arg
, zero_call_used_regs_opts
[i
].name
) == 0)
2171 flags
= zero_call_used_regs_opts
[i
].flag
;
2176 error ("unrecognized argument to %<-fzero-call-used-regs=%>: %qs", arg
);
2181 /* Parse -falign-NAME format for a FLAG value. Return individual
2182 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
2183 set, print error message at LOC location. */
2186 parse_and_check_align_values (const char *flag
,
2188 auto_vec
<unsigned> &result_values
,
2192 char *str
= xstrdup (flag
);
2193 for (char *p
= strtok (str
, ":"); p
; p
= strtok (NULL
, ":"))
2196 int v
= strtol (p
, &end
, 10);
2197 if (*end
!= '\0' || v
< 0)
2200 error_at (loc
, "invalid arguments for %<-falign-%s%> option: %qs",
2206 result_values
.safe_push ((unsigned)v
);
2211 /* Check that we have a correct number of values. */
2212 if (result_values
.is_empty () || result_values
.length () > 4)
2215 error_at (loc
, "invalid number of arguments for %<-falign-%s%> "
2216 "option: %qs", name
, flag
);
2220 for (unsigned i
= 0; i
< result_values
.length (); i
++)
2221 if (result_values
[i
] > MAX_CODE_ALIGN_VALUE
)
2224 error_at (loc
, "%<-falign-%s%> is not between 0 and %d",
2225 name
, MAX_CODE_ALIGN_VALUE
);
2232 /* Check that alignment value FLAG for -falign-NAME is valid at a given
2233 location LOC. OPT_STR points to the stored -falign-NAME=argument and
2234 OPT_FLAG points to the associated -falign-NAME on/off flag. */
2237 check_alignment_argument (location_t loc
, const char *flag
, const char *name
,
2238 int *opt_flag
, const char **opt_str
)
2240 auto_vec
<unsigned> align_result
;
2241 parse_and_check_align_values (flag
, name
, align_result
, true, loc
);
2243 if (align_result
.length() >= 1 && align_result
[0] == 0)
2250 /* Parse argument of -fpatchable-function-entry option ARG and store
2251 corresponding values to PATCH_AREA_SIZE and PATCH_AREA_START.
2252 If REPORT_ERROR is set to true, generate error for a problematic
2253 option arguments. */
2256 parse_and_check_patch_area (const char *arg
, bool report_error
,
2257 HOST_WIDE_INT
*patch_area_size
,
2258 HOST_WIDE_INT
*patch_area_start
)
2260 *patch_area_size
= 0;
2261 *patch_area_start
= 0;
2266 char *patch_area_arg
= xstrdup (arg
);
2267 char *comma
= strchr (patch_area_arg
, ',');
2271 *patch_area_size
= integral_argument (patch_area_arg
);
2272 *patch_area_start
= integral_argument (comma
+ 1);
2275 *patch_area_size
= integral_argument (patch_area_arg
);
2277 if (*patch_area_size
< 0
2278 || *patch_area_size
> USHRT_MAX
2279 || *patch_area_start
< 0
2280 || *patch_area_start
> USHRT_MAX
2281 || *patch_area_size
< *patch_area_start
)
2283 error ("invalid arguments for %<-fpatchable-function-entry%>");
2285 free (patch_area_arg
);
2288 /* Print help when OPT__help_ is set. */
2291 print_help (struct gcc_options
*opts
, unsigned int lang_mask
,
2292 const char *help_option_argument
)
2294 const char *a
= help_option_argument
;
2295 unsigned int include_flags
= 0;
2296 /* Note - by default we include undocumented options when listing
2297 specific classes. If you only want to see documented options
2298 then add ",^undocumented" to the --help= option. E.g.:
2300 --help=target,^undocumented */
2301 unsigned int exclude_flags
= 0;
2303 if (lang_mask
== CL_DRIVER
)
2306 /* Walk along the argument string, parsing each word in turn.
2308 arg = [^]{word}[,{arg}]
2309 word = {optimizers|target|warnings|undocumented|
2310 params|common|<language>} */
2320 { "optimizers", CL_OPTIMIZATION
},
2321 { "target", CL_TARGET
},
2322 { "warnings", CL_WARNING
},
2323 { "undocumented", CL_UNDOCUMENTED
},
2324 { "params", CL_PARAMS
},
2325 { "joined", CL_JOINED
},
2326 { "separate", CL_SEPARATE
},
2327 { "common", CL_COMMON
},
2330 unsigned int *pflags
;
2332 unsigned int lang_flag
, specific_flag
;
2341 error ("missing argument to %qs", "--help=^");
2344 pflags
= &exclude_flags
;
2347 pflags
= &include_flags
;
2349 comma
= strchr (a
, ',');
2360 /* Check to see if the string matches an option class name. */
2361 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
2362 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
2364 specific_flag
= specifics
[i
].flag
;
2368 /* Check to see if the string matches a language name.
2369 Note - we rely upon the alpha-sorted nature of the entries in
2370 the lang_names array, specifically that shorter names appear
2371 before their longer variants. (i.e. C before C++). That way
2372 when we are attempting to match --help=c for example we will
2373 match with C first and not C++. */
2374 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
2375 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
2377 lang_flag
= 1U << i
;
2381 if (specific_flag
!= 0)
2384 *pflags
|= specific_flag
;
2387 /* The option's argument matches both the start of a
2388 language name and the start of an option class name.
2389 We have a special case for when the user has
2390 specified "--help=c", but otherwise we have to issue
2392 if (strncasecmp (a
, "c", len
) == 0)
2393 *pflags
|= lang_flag
;
2396 "%<--help%> argument %q.*s is ambiguous, "
2397 "please be more specific",
2401 else if (lang_flag
!= 0)
2402 *pflags
|= lang_flag
;
2405 "unrecognized argument to %<--help=%> option: %q.*s",
2413 /* We started using PerFunction/Optimization for parameters and
2414 a warning. We should exclude these from optimization options. */
2415 if (include_flags
& CL_OPTIMIZATION
)
2416 exclude_flags
|= CL_WARNING
;
2417 if (!(include_flags
& CL_PARAMS
))
2418 exclude_flags
|= CL_PARAMS
;
2421 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
2425 /* Handle target- and language-independent options. Return zero to
2426 generate an "unknown option" message. Only options that need
2427 extra handling need to be listed here; if you simply want
2428 DECODED->value assigned to a variable, it happens automatically. */
2431 common_handle_option (struct gcc_options
*opts
,
2432 struct gcc_options
*opts_set
,
2433 const struct cl_decoded_option
*decoded
,
2434 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
2436 const struct cl_option_handlers
*handlers
,
2437 diagnostic_context
*dc
,
2438 void (*target_option_override_hook
) (void))
2440 size_t scode
= decoded
->opt_index
;
2441 const char *arg
= decoded
->arg
;
2442 HOST_WIDE_INT value
= decoded
->value
;
2443 enum opt_code code
= (enum opt_code
) scode
;
2445 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
2451 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
2452 unsigned int undoc_mask
;
2455 if (lang_mask
== CL_DRIVER
)
2458 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
2461 target_option_override_hook ();
2462 /* First display any single language specific options. */
2463 for (i
= 0; i
< cl_lang_count
; i
++)
2465 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
2467 /* Next display any multi language specific options. */
2468 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
2469 /* Then display any remaining, non-language options. */
2470 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
2472 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
2473 opts
->x_exit_after_options
= true;
2477 case OPT__target_help
:
2478 if (lang_mask
== CL_DRIVER
)
2481 target_option_override_hook ();
2482 print_specific_help (CL_TARGET
, CL_UNDOCUMENTED
, 0, opts
, lang_mask
);
2483 opts
->x_exit_after_options
= true;
2488 help_option_arguments
.safe_push (arg
);
2489 opts
->x_exit_after_options
= true;
2494 if (lang_mask
== CL_DRIVER
)
2497 opts
->x_exit_after_options
= true;
2500 case OPT__completion_
:
2503 case OPT_fsanitize_
:
2504 opts
->x_flag_sanitize
2505 = parse_sanitizer_options (arg
, loc
, code
,
2506 opts
->x_flag_sanitize
, value
, true);
2508 /* Kernel ASan implies normal ASan but does not yet support
2510 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
2512 SET_OPTION_IF_UNSET (opts
, opts_set
,
2513 param_asan_instrumentation_with_call_threshold
,
2515 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_globals
, 0);
2516 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_stack
, 0);
2517 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_protect_allocas
, 0);
2518 SET_OPTION_IF_UNSET (opts
, opts_set
, param_asan_use_after_return
, 0);
2520 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_HWADDRESS
)
2522 SET_OPTION_IF_UNSET (opts
, opts_set
,
2523 param_hwasan_instrument_stack
, 0);
2524 SET_OPTION_IF_UNSET (opts
, opts_set
,
2525 param_hwasan_random_frame_tag
, 0);
2526 SET_OPTION_IF_UNSET (opts
, opts_set
,
2527 param_hwasan_instrument_allocas
, 0);
2531 case OPT_fsanitize_recover_
:
2532 opts
->x_flag_sanitize_recover
2533 = parse_sanitizer_options (arg
, loc
, code
,
2534 opts
->x_flag_sanitize_recover
, value
, true);
2537 case OPT_fasan_shadow_offset_
:
2541 case OPT_fsanitize_address_use_after_scope
:
2542 opts
->x_flag_sanitize_address_use_after_scope
= value
;
2545 case OPT_fsanitize_recover
:
2547 opts
->x_flag_sanitize_recover
2548 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)
2549 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2551 opts
->x_flag_sanitize_recover
2552 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2555 case OPT_fsanitize_coverage_
:
2556 opts
->x_flag_sanitize_coverage
= value
;
2563 /* Currently handled in a prescan. */
2567 dc
->warning_as_error_requested
= value
;
2571 if (lang_mask
== CL_DRIVER
)
2574 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
2575 opts
, opts_set
, loc
, dc
);
2578 case OPT_Wfatal_errors
:
2579 dc
->fatal_errors
= value
;
2582 case OPT_Wstack_usage_
:
2583 opts
->x_flag_stack_usage_info
= value
!= -1;
2586 case OPT_Wstrict_aliasing
:
2587 set_Wstrict_aliasing (opts
, value
);
2590 case OPT_Wstrict_overflow
:
2591 opts
->x_warn_strict_overflow
= (value
2592 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2596 case OPT_Wsystem_headers
:
2597 dc
->dc_warn_system_headers
= value
;
2601 opts
->x_flag_gen_aux_info
= 1;
2605 decode_d_option (arg
, opts
, loc
, dc
);
2608 case OPT_fcall_used_
:
2609 case OPT_fcall_saved_
:
2617 case OPT_fdebug_prefix_map_
:
2618 case OPT_ffile_prefix_map_
:
2622 case OPT_fcallgraph_info
:
2623 opts
->x_flag_callgraph_info
= CALLGRAPH_INFO_NAKED
;
2626 case OPT_fcallgraph_info_
:
2629 my_arg
= xstrdup (arg
);
2630 p
= strtok (my_arg
, ",");
2633 if (strcmp (p
, "su") == 0)
2635 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_STACK_USAGE
;
2636 opts
->x_flag_stack_usage_info
= true;
2638 else if (strcmp (p
, "da") == 0)
2639 opts
->x_flag_callgraph_info
|= CALLGRAPH_INFO_DYNAMIC_ALLOC
;
2642 p
= strtok (NULL
, ",");
2648 case OPT_fdiagnostics_show_location_
:
2649 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2652 case OPT_fdiagnostics_show_caret
:
2653 dc
->show_caret
= value
;
2656 case OPT_fdiagnostics_show_labels
:
2657 dc
->show_labels_p
= value
;
2660 case OPT_fdiagnostics_show_line_numbers
:
2661 dc
->show_line_numbers_p
= value
;
2664 case OPT_fdiagnostics_color_
:
2665 diagnostic_color_init (dc
, value
);
2668 case OPT_fdiagnostics_urls_
:
2669 diagnostic_urls_init (dc
, value
);
2672 case OPT_fdiagnostics_format_
:
2673 diagnostic_output_format_init (dc
,
2674 (enum diagnostics_output_format
)value
);
2677 case OPT_fdiagnostics_parseable_fixits
:
2678 dc
->extra_output_kind
= (value
2679 ? EXTRA_DIAGNOSTIC_OUTPUT_fixits_v1
2680 : EXTRA_DIAGNOSTIC_OUTPUT_none
);
2683 case OPT_fdiagnostics_column_unit_
:
2684 dc
->column_unit
= (enum diagnostics_column_unit
)value
;
2687 case OPT_fdiagnostics_column_origin_
:
2688 dc
->column_origin
= value
;
2691 case OPT_fdiagnostics_show_cwe
:
2692 dc
->show_cwe
= value
;
2695 case OPT_fdiagnostics_path_format_
:
2696 dc
->path_format
= (enum diagnostic_path_format
)value
;
2699 case OPT_fdiagnostics_show_path_depths
:
2700 dc
->show_path_depths
= value
;
2703 case OPT_fdiagnostics_show_option
:
2704 dc
->show_option_requested
= value
;
2707 case OPT_fdiagnostics_minimum_margin_width_
:
2708 dc
->min_margin_width
= value
;
2715 case OPT_ffast_math
:
2716 set_fast_math_flags (opts
, value
);
2719 case OPT_funsafe_math_optimizations
:
2720 set_unsafe_math_optimizations_flags (opts
, value
);
2727 case OPT_finline_limit_
:
2728 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_single
,
2730 SET_OPTION_IF_UNSET (opts
, opts_set
, param_max_inline_insns_auto
,
2734 case OPT_finstrument_functions_exclude_function_list_
:
2735 add_comma_separated_to_vector
2736 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2739 case OPT_finstrument_functions_exclude_file_list_
:
2740 add_comma_separated_to_vector
2741 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2744 case OPT_fmessage_length_
:
2745 pp_set_line_maximum_length (dc
->printer
, value
);
2746 diagnostic_set_caret_max_width (dc
, value
);
2750 case OPT_fopt_info_
:
2754 case OPT_foffload_options_
:
2758 case OPT_foffload_abi_
:
2759 #ifdef ACCEL_COMPILER
2760 /* Handled in the 'mkoffload's. */
2762 error_at (loc
, "%<-foffload-abi%> option can be specified only for "
2763 "offload compiler");
2767 case OPT_fpack_struct_
:
2768 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2770 "structure alignment must be a small power of two, not %wu",
2773 opts
->x_initial_max_fld_align
= value
;
2777 case OPT_fplugin_arg_
:
2781 case OPT_fprofile_use_
:
2782 opts
->x_profile_data_prefix
= xstrdup (arg
);
2783 opts
->x_flag_profile_use
= true;
2785 /* No break here - do -fprofile-use processing. */
2787 case OPT_fprofile_use
:
2788 enable_fdo_optimizations (opts
, opts_set
, value
);
2789 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_reorder_functions
,
2791 /* Indirect call profiling should do all useful transformations
2792 speculative devirtualization does. */
2793 if (opts
->x_flag_value_profile_transformations
)
2794 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_devirtualize_speculatively
,
2798 case OPT_fauto_profile_
:
2799 opts
->x_auto_profile_file
= xstrdup (arg
);
2800 opts
->x_flag_auto_profile
= true;
2802 /* No break here - do -fauto-profile processing. */
2804 case OPT_fauto_profile
:
2805 enable_fdo_optimizations (opts
, opts_set
, value
);
2806 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_correction
, value
);
2807 SET_OPTION_IF_UNSET (opts
, opts_set
,
2808 param_early_inliner_max_iterations
, 10);
2811 case OPT_fprofile_generate_
:
2812 opts
->x_profile_data_prefix
= xstrdup (arg
);
2814 /* No break here - do -fprofile-generate processing. */
2816 case OPT_fprofile_generate
:
2817 SET_OPTION_IF_UNSET (opts
, opts_set
, profile_arc_flag
, value
);
2818 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_profile_values
, value
);
2819 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_inline_functions
, value
);
2820 SET_OPTION_IF_UNSET (opts
, opts_set
, flag_ipa_bit_cp
, value
);
2823 case OPT_fprofile_info_section
:
2824 opts
->x_profile_info_section
= ".gcov_info";
2827 case OPT_fpatchable_function_entry_
:
2829 HOST_WIDE_INT patch_area_size
, patch_area_start
;
2830 parse_and_check_patch_area (arg
, true, &patch_area_size
,
2835 case OPT_ftree_vectorize
:
2836 /* Automatically sets -ftree-loop-vectorize and
2837 -ftree-slp-vectorize. Nothing more to do here. */
2839 case OPT_fzero_call_used_regs_
:
2840 opts
->x_flag_zero_call_used_regs
2841 = parse_zero_call_used_regs_options (arg
);
2844 case OPT_fshow_column
:
2845 dc
->show_column
= value
;
2848 case OPT_frandom_seed
:
2849 /* The real switch is -fno-random-seed. */
2855 case OPT_frandom_seed_
:
2859 case OPT_fsched_verbose_
:
2860 #ifdef INSN_SCHEDULING
2861 /* Handled with Var in common.opt. */
2867 case OPT_fsched_stalled_insns_
:
2868 opts
->x_flag_sched_stalled_insns
= value
;
2869 if (opts
->x_flag_sched_stalled_insns
== 0)
2870 opts
->x_flag_sched_stalled_insns
= -1;
2873 case OPT_fsched_stalled_insns_dep_
:
2874 opts
->x_flag_sched_stalled_insns_dep
= value
;
2877 case OPT_fstack_check_
:
2878 if (!strcmp (arg
, "no"))
2879 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
2880 else if (!strcmp (arg
, "generic"))
2881 /* This is the old stack checking method. */
2882 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2883 ? FULL_BUILTIN_STACK_CHECK
2884 : GENERIC_STACK_CHECK
;
2885 else if (!strcmp (arg
, "specific"))
2886 /* This is the new stack checking method. */
2887 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2888 ? FULL_BUILTIN_STACK_CHECK
2889 : STACK_CHECK_STATIC_BUILTIN
2890 ? STATIC_BUILTIN_STACK_CHECK
2891 : GENERIC_STACK_CHECK
;
2893 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
2896 case OPT_fstack_limit
:
2897 /* The real switch is -fno-stack-limit. */
2903 case OPT_fstack_limit_register_
:
2904 case OPT_fstack_limit_symbol_
:
2908 case OPT_fstack_usage
:
2909 opts
->x_flag_stack_usage
= value
;
2910 opts
->x_flag_stack_usage_info
= value
!= 0;
2914 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
2919 set_debug_level (BTF_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2920 /* set the debug level to level 2, but if already at level 3,
2922 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
2923 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
2927 set_debug_level (CTF_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2928 /* CTF generation feeds off DWARF dies. For optimal CTF, switch debug
2929 info level to 2. If off or at level 1, set it to level 2, but if
2930 already at level 3, don't lower it. */
2931 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
2932 && opts
->x_ctf_debug_info_level
> CTFINFO_LEVEL_NONE
)
2933 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
2937 if (arg
&& strlen (arg
) != 0)
2939 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
2940 "use %<-gdwarf-%s%> for DWARF version "
2941 "or %<-gdwarf%> %<-g%s%> for debug level", arg
, arg
, arg
);
2945 value
= opts
->x_dwarf_version
;
2949 if (value
< 2 || value
> 5)
2950 error_at (loc
, "dwarf version %wu is not supported", value
);
2952 opts
->x_dwarf_version
= value
;
2953 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
2957 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
2962 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
, opts
, opts_set
,
2967 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2972 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
, opts
, opts_set
,
2978 /* Handled completely via specs. */
2981 case OPT_pedantic_errors
:
2982 dc
->pedantic_errors
= 1;
2983 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
2985 handlers
, opts
, opts_set
,
2990 opts
->x_flag_lto
= value
? "" : NULL
;
2994 if (strcmp (arg
, "none") != 0
2995 && strcmp (arg
, "jobserver") != 0
2996 && strcmp (arg
, "auto") != 0
2999 "unrecognized argument to %<-flto=%> option: %qs", arg
);
3003 dc
->dc_inhibit_warnings
= true;
3006 case OPT_fmax_errors_
:
3007 dc
->max_errors
= value
;
3010 case OPT_fuse_ld_bfd
:
3011 case OPT_fuse_ld_gold
:
3012 case OPT_fuse_ld_lld
:
3013 case OPT_fuse_linker_plugin
:
3014 /* No-op. Used by the driver and passed to us because it starts with f.*/
3019 opts
->x_flag_trapv
= 0;
3024 opts
->x_flag_wrapv
= 0;
3027 case OPT_fstrict_overflow
:
3028 opts
->x_flag_wrapv
= !value
;
3029 opts
->x_flag_wrapv_pointer
= !value
;
3031 opts
->x_flag_trapv
= 0;
3035 opts
->x_flag_ipa_icf_functions
= value
;
3036 opts
->x_flag_ipa_icf_variables
= value
;
3039 case OPT_falign_loops_
:
3040 check_alignment_argument (loc
, arg
, "loops",
3041 &opts
->x_flag_align_loops
,
3042 &opts
->x_str_align_loops
);
3045 case OPT_falign_jumps_
:
3046 check_alignment_argument (loc
, arg
, "jumps",
3047 &opts
->x_flag_align_jumps
,
3048 &opts
->x_str_align_jumps
);
3051 case OPT_falign_labels_
:
3052 check_alignment_argument (loc
, arg
, "labels",
3053 &opts
->x_flag_align_labels
,
3054 &opts
->x_str_align_labels
);
3057 case OPT_falign_functions_
:
3058 check_alignment_argument (loc
, arg
, "functions",
3059 &opts
->x_flag_align_functions
,
3060 &opts
->x_str_align_functions
);
3064 /* It is documented that we silently ignore silly values. */
3065 if (value
>= 1 && value
<= 100)
3066 dc
->tabstop
= value
;
3070 /* If the flag was handled in a standard way, assume the lack of
3071 processing here is intentional. */
3072 gcc_assert (option_flag_var (scode
, opts
));
3076 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
3081 /* Used to set the level of strict aliasing warnings in OPTS,
3082 when no level is specified (i.e., when -Wstrict-aliasing, and not
3083 -Wstrict-aliasing=level was given).
3084 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
3085 and 0 otherwise. After calling this function, wstrict_aliasing will be
3086 set to the default value of -Wstrict_aliasing=level, currently 3. */
3088 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
3090 gcc_assert (onoff
== 0 || onoff
== 1);
3092 opts
->x_warn_strict_aliasing
= 3;
3094 opts
->x_warn_strict_aliasing
= 0;
3097 /* The following routines are useful in setting all the flags that
3098 -ffast-math and -fno-fast-math imply. */
3100 set_fast_math_flags (struct gcc_options
*opts
, int set
)
3102 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
3104 opts
->x_flag_unsafe_math_optimizations
= set
;
3105 set_unsafe_math_optimizations_flags (opts
, set
);
3107 if (!opts
->frontend_set_flag_finite_math_only
)
3108 opts
->x_flag_finite_math_only
= set
;
3109 if (!opts
->frontend_set_flag_errno_math
)
3110 opts
->x_flag_errno_math
= !set
;
3113 if (opts
->frontend_set_flag_excess_precision
== EXCESS_PRECISION_DEFAULT
)
3114 opts
->x_flag_excess_precision
3115 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
3116 if (!opts
->frontend_set_flag_signaling_nans
)
3117 opts
->x_flag_signaling_nans
= 0;
3118 if (!opts
->frontend_set_flag_rounding_math
)
3119 opts
->x_flag_rounding_math
= 0;
3120 if (!opts
->frontend_set_flag_cx_limited_range
)
3121 opts
->x_flag_cx_limited_range
= 1;
3125 /* When -funsafe-math-optimizations is set the following
3126 flags are set as well. */
3128 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
3130 if (!opts
->frontend_set_flag_trapping_math
)
3131 opts
->x_flag_trapping_math
= !set
;
3132 if (!opts
->frontend_set_flag_signed_zeros
)
3133 opts
->x_flag_signed_zeros
= !set
;
3134 if (!opts
->frontend_set_flag_associative_math
)
3135 opts
->x_flag_associative_math
= set
;
3136 if (!opts
->frontend_set_flag_reciprocal_math
)
3137 opts
->x_flag_reciprocal_math
= set
;
3140 /* Return true iff flags in OPTS are set as if -ffast-math. */
3142 fast_math_flags_set_p (const struct gcc_options
*opts
)
3144 return (!opts
->x_flag_trapping_math
3145 && opts
->x_flag_unsafe_math_optimizations
3146 && opts
->x_flag_finite_math_only
3147 && !opts
->x_flag_signed_zeros
3148 && !opts
->x_flag_errno_math
3149 && opts
->x_flag_excess_precision
== EXCESS_PRECISION_FAST
);
3152 /* Return true iff flags are set as if -ffast-math but using the flags stored
3153 in the struct cl_optimization structure. */
3155 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
3157 return (!opt
->x_flag_trapping_math
3158 && opt
->x_flag_unsafe_math_optimizations
3159 && opt
->x_flag_finite_math_only
3160 && !opt
->x_flag_signed_zeros
3161 && !opt
->x_flag_errno_math
);
3164 /* Handle a debug output -g switch for options OPTS
3165 (OPTS_SET->x_write_symbols storing whether a debug format was passed
3166 explicitly), location LOC. EXTENDED is true or false to support
3167 extended output (2 is special and means "-ggdb" was given). */
3169 set_debug_level (uint32_t dinfo
, int extended
, const char *arg
,
3170 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
3173 opts
->x_use_gnu_debug_info_extensions
= extended
;
3175 if (dinfo
== NO_DEBUG
)
3177 if (opts
->x_write_symbols
== NO_DEBUG
)
3179 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
3183 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
3184 if (opts
->x_write_symbols
& CTF_DEBUG
)
3185 opts
->x_write_symbols
|= DWARF2_DEBUG
;
3187 opts
->x_write_symbols
= DWARF2_DEBUG
;
3188 #elif defined DBX_DEBUGGING_INFO
3189 opts
->x_write_symbols
= DBX_DEBUG
;
3193 if (opts
->x_write_symbols
== NO_DEBUG
)
3194 warning_at (loc
, 0, "target system does not support debug output");
3196 else if ((opts
->x_write_symbols
& CTF_DEBUG
)
3197 || (opts
->x_write_symbols
& BTF_DEBUG
))
3199 opts
->x_write_symbols
|= DWARF2_DEBUG
;
3200 opts_set
->x_write_symbols
|= DWARF2_DEBUG
;
3205 /* Make and retain the choice if both CTF and DWARF debug info are to
3207 if (((dinfo
== DWARF2_DEBUG
) || (dinfo
== CTF_DEBUG
))
3208 && ((opts
->x_write_symbols
== (DWARF2_DEBUG
|CTF_DEBUG
))
3209 || (opts
->x_write_symbols
== DWARF2_DEBUG
)
3210 || (opts
->x_write_symbols
== CTF_DEBUG
)))
3212 opts
->x_write_symbols
|= dinfo
;
3213 opts_set
->x_write_symbols
|= dinfo
;
3215 /* However, CTF and BTF are not allowed together at this time. */
3216 else if (((dinfo
== DWARF2_DEBUG
) || (dinfo
== BTF_DEBUG
))
3217 && ((opts
->x_write_symbols
== (DWARF2_DEBUG
|BTF_DEBUG
))
3218 || (opts
->x_write_symbols
== DWARF2_DEBUG
)
3219 || (opts
->x_write_symbols
== BTF_DEBUG
)))
3221 opts
->x_write_symbols
|= dinfo
;
3222 opts_set
->x_write_symbols
|= dinfo
;
3226 /* Does it conflict with an already selected debug format? */
3227 if (opts_set
->x_write_symbols
!= NO_DEBUG
3228 && opts
->x_write_symbols
!= NO_DEBUG
3229 && dinfo
!= opts
->x_write_symbols
)
3231 gcc_assert (debug_set_count (dinfo
) <= 1);
3232 error_at (loc
, "debug format %qs conflicts with prior selection",
3233 debug_type_names
[debug_set_to_format (dinfo
)]);
3235 opts
->x_write_symbols
= dinfo
;
3236 opts_set
->x_write_symbols
= dinfo
;
3240 if (dinfo
!= BTF_DEBUG
)
3242 /* A debug flag without a level defaults to level 2.
3243 If off or at level 1, set it to level 2, but if already
3244 at level 3, don't lower it. */
3247 if (dinfo
== CTF_DEBUG
)
3248 opts
->x_ctf_debug_info_level
= CTFINFO_LEVEL_NORMAL
;
3249 else if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
3250 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3254 int argval
= integral_argument (arg
);
3256 error_at (loc
, "unrecognized debug output level %qs", arg
);
3257 else if (argval
> 3)
3258 error_at (loc
, "debug output level %qs is too high", arg
);
3261 if (dinfo
== CTF_DEBUG
)
3262 opts
->x_ctf_debug_info_level
3263 = (enum ctf_debug_info_levels
) argval
;
3265 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
3269 else if (*arg
!= '\0')
3270 error_at (loc
, "unrecognized btf debug output level %qs", arg
);
3273 /* Arrange to dump core on error for diagnostic context DC. (The
3274 regular error message is still printed first, except in the case of
3278 setup_core_dumping (diagnostic_context
*dc
)
3281 signal (SIGABRT
, SIG_DFL
);
3283 #if defined(HAVE_SETRLIMIT)
3286 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
3287 fatal_error (input_location
, "getting core file size maximum limit: %m");
3288 rlim
.rlim_cur
= rlim
.rlim_max
;
3289 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
3290 fatal_error (input_location
,
3291 "setting core file size limit to maximum: %m");
3294 diagnostic_abort_on_error (dc
);
3297 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
3298 diagnostic context DC. */
3301 decode_d_option (const char *arg
, struct gcc_options
*opts
,
3302 location_t loc
, diagnostic_context
*dc
)
3310 opts
->x_flag_debug_asm
= 1;
3313 opts
->x_flag_print_asm_name
= 1;
3316 opts
->x_flag_dump_rtl_in_asm
= 1;
3317 opts
->x_flag_print_asm_name
= 1;
3320 opts
->x_rtl_dump_and_exit
= 1;
3322 case 'D': /* These are handled by the preprocessor. */
3329 setup_core_dumping (dc
);
3332 opts
->x_flag_dump_all_passed
= true;
3336 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
3341 /* Enable (or disable if VALUE is 0) a warning option ARG (language
3342 mask LANG_MASK, option handlers HANDLERS) as an error for option
3343 structures OPTS and OPTS_SET, diagnostic context DC (possibly
3344 NULL), location LOC. This is used by -Werror=. */
3347 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
3348 const struct cl_option_handlers
*handlers
,
3349 struct gcc_options
*opts
,
3350 struct gcc_options
*opts_set
,
3351 location_t loc
, diagnostic_context
*dc
)
3356 new_option
= XNEWVEC (char, strlen (arg
) + 2);
3357 new_option
[0] = 'W';
3358 strcpy (new_option
+ 1, arg
);
3359 option_index
= find_opt (new_option
, lang_mask
);
3360 if (option_index
== OPT_SPECIAL_unknown
)
3363 const char *hint
= op
.suggest_option (new_option
);
3365 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>;"
3366 " did you mean %<-%s%>?", value
? "" : "no-",
3367 arg
, new_option
, hint
);
3369 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>",
3370 value
? "" : "no-", arg
, new_option
);
3372 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
3373 error_at (loc
, "%<-Werror=%s%>: %<-%s%> is not an option that "
3374 "controls warnings", arg
, new_option
);
3377 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
3378 const char *arg
= NULL
;
3380 if (cl_options
[option_index
].flags
& CL_JOINED
)
3381 arg
= new_option
+ cl_options
[option_index
].opt_len
;
3382 control_warning_option (option_index
, (int) kind
, arg
, value
,
3384 handlers
, opts
, opts_set
, dc
);
3389 /* Return malloced memory for the name of the option OPTION_INDEX
3390 which enabled a diagnostic (context CONTEXT), originally of type
3391 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
3395 option_name (diagnostic_context
*context
, int option_index
,
3396 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
3400 /* A warning classified as an error. */
3401 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
3402 && diag_kind
== DK_ERROR
)
3403 return concat (cl_options
[OPT_Werror_
].opt_text
,
3404 /* Skip over "-W". */
3405 cl_options
[option_index
].opt_text
+ 2,
3407 /* A warning with option. */
3409 return xstrdup (cl_options
[option_index
].opt_text
);
3411 /* A warning without option classified as an error. */
3412 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
3413 || diag_kind
== DK_WARNING
)
3414 && context
->warning_as_error_requested
)
3415 return xstrdup (cl_options
[OPT_Werror
].opt_text
);
3420 /* Get the page within the documentation for this option. */
3423 get_option_html_page (int option_index
)
3425 const cl_option
*cl_opt
= &cl_options
[option_index
];
3427 /* Analyzer options are on their own page. */
3428 if (strstr (cl_opt
->opt_text
, "analyzer-"))
3429 return "gcc/Static-Analyzer-Options.html";
3431 /* Handle -flto= option. */
3432 if (strstr (cl_opt
->opt_text
, "flto"))
3433 return "gcc/Optimize-Options.html";
3436 if ((cl_opt
->flags
& CL_Fortran
) != 0
3437 /* If it is option common to both C/C++ and Fortran, it is documented
3438 in gcc/ rather than gfortran/ docs. */
3439 && (cl_opt
->flags
& CL_C
) == 0
3441 && (cl_opt
->flags
& CL_CXX
) == 0
3444 return "gfortran/Error-and-Warning-Options.html";
3447 return "gcc/Warning-Options.html";
3450 /* Return malloced memory for a URL describing the option OPTION_INDEX
3451 which enabled a diagnostic (context CONTEXT). */
3454 get_option_url (diagnostic_context
*, int option_index
)
3457 return concat (/* DOCUMENTATION_ROOT_URL should be supplied via -D by
3458 the Makefile (see --with-documentation-root-url), and
3459 should have a trailing slash. */
3460 DOCUMENTATION_ROOT_URL
,
3462 /* get_option_html_page will return something like
3463 "gcc/Warning-Options.html". */
3464 get_option_html_page (option_index
),
3466 /* Expect an anchor of the form "index-Wfoo" e.g.
3467 <a name="index-Wformat"></a>, and thus an id within
3468 the URL of "#index-Wformat". */
3469 "#index", cl_options
[option_index
].opt_text
,
3475 /* Return a heap allocated producer with command line options. */
3478 gen_command_line_string (cl_decoded_option
*options
,
3479 unsigned int options_count
)
3481 auto_vec
<const char *> switches
;
3482 char *options_string
, *tail
;
3486 for (unsigned i
= 0; i
< options_count
; i
++)
3487 switch (options
[i
].opt_index
)
3492 case OPT_dumpbase_ext
:
3502 case OPT_SPECIAL_unknown
:
3503 case OPT_SPECIAL_ignore
:
3504 case OPT_SPECIAL_warn_removed
:
3505 case OPT_SPECIAL_program_name
:
3506 case OPT_SPECIAL_input_file
:
3507 case OPT_grecord_gcc_switches
:
3508 case OPT_frecord_gcc_switches
:
3509 case OPT__output_pch_
:
3510 case OPT_fdiagnostics_show_location_
:
3511 case OPT_fdiagnostics_show_option
:
3512 case OPT_fdiagnostics_show_caret
:
3513 case OPT_fdiagnostics_show_labels
:
3514 case OPT_fdiagnostics_show_line_numbers
:
3515 case OPT_fdiagnostics_color_
:
3516 case OPT_fdiagnostics_format_
:
3517 case OPT_fverbose_asm
:
3521 case OPT_nostdinc__
:
3522 case OPT_fpreprocessed
:
3523 case OPT_fltrans_output_list_
:
3524 case OPT_fresolution_
:
3525 case OPT_fdebug_prefix_map_
:
3526 case OPT_fmacro_prefix_map_
:
3527 case OPT_ffile_prefix_map_
:
3528 case OPT_fcompare_debug
:
3530 case OPT_fchecking_
:
3535 const char *lto_canonical
= "-flto";
3536 switches
.safe_push (lto_canonical
);
3537 len
+= strlen (lto_canonical
) + 1;
3541 if (cl_options
[options
[i
].opt_index
].flags
3542 & CL_NO_DWARF_RECORD
)
3544 gcc_checking_assert (options
[i
].canonical_option
[0][0] == '-');
3545 switch (options
[i
].canonical_option
[0][1])
3552 if (strncmp (options
[i
].canonical_option
[0] + 2,
3559 switches
.safe_push (options
[i
].orig_option_with_args_text
);
3560 len
+= strlen (options
[i
].orig_option_with_args_text
) + 1;
3564 options_string
= XNEWVEC (char, len
+ 1);
3565 tail
= options_string
;
3568 FOR_EACH_VEC_ELT (switches
, i
, p
)
3571 memcpy (tail
, p
, len
);
3573 if (i
!= switches
.length () - 1)
3581 return options_string
;
3584 /* Return a heap allocated producer string including command line options. */
3587 gen_producer_string (const char *language_string
, cl_decoded_option
*options
,
3588 unsigned int options_count
)
3590 char *cmdline
= gen_command_line_string (options
, options_count
);
3591 char *combined
= concat (language_string
, " ", version_string
, " ",
3599 namespace selftest
{
3601 /* Verify that get_option_html_page works as expected. */
3604 test_get_option_html_page ()
3606 ASSERT_STREQ (get_option_html_page (OPT_Wcpp
), "gcc/Warning-Options.html");
3607 ASSERT_STREQ (get_option_html_page (OPT_Wanalyzer_double_free
),
3608 "gcc/Static-Analyzer-Options.html");
3610 ASSERT_STREQ (get_option_html_page (OPT_Wline_truncation
),
3611 "gfortran/Error-and-Warning-Options.html");
3615 /* Run all of the selftests within this file. */
3620 test_get_option_html_page ();
3623 } // namespace selftest
3625 #endif /* #if CHECKING_P */