1 /* Command line option handling.
2 Copyright (C) 2002-2019 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"
29 #include "diagnostic.h"
30 #include "opts-diagnostic.h"
31 #include "insn-attr-common.h"
32 #include "common/common-target.h"
33 #include "spellcheck.h"
34 #include "opt-suggestions.h"
35 #include "diagnostic-color.h"
37 static void set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
);
39 /* Indexed by enum debug_info_type. */
40 const char *const debug_type_names
[] =
42 "none", "stabs", "dwarf-2", "xcoff", "vms"
45 /* Parse the -femit-struct-debug-detailed option value
46 and set the flag variables. */
48 #define MATCH( prefix, string ) \
49 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
50 ? ((string += sizeof prefix - 1), 1) : 0)
53 set_struct_debug_option (struct gcc_options
*opts
, location_t loc
,
56 /* various labels for comparison */
57 static const char dfn_lbl
[] = "dfn:", dir_lbl
[] = "dir:", ind_lbl
[] = "ind:";
58 static const char ord_lbl
[] = "ord:", gen_lbl
[] = "gen:";
59 static const char none_lbl
[] = "none", any_lbl
[] = "any";
60 static const char base_lbl
[] = "base", sys_lbl
[] = "sys";
62 enum debug_struct_file files
= DINFO_STRUCT_FILE_ANY
;
63 /* Default is to apply to as much as possible. */
64 enum debug_info_usage usage
= DINFO_USAGE_NUM_ENUMS
;
68 if (MATCH (dfn_lbl
, spec
))
69 usage
= DINFO_USAGE_DFN
;
70 else if (MATCH (dir_lbl
, spec
))
71 usage
= DINFO_USAGE_DIR_USE
;
72 else if (MATCH (ind_lbl
, spec
))
73 usage
= DINFO_USAGE_IND_USE
;
75 /* Generics or not? */
76 if (MATCH (ord_lbl
, spec
))
78 else if (MATCH (gen_lbl
, spec
))
81 /* What allowable environment? */
82 if (MATCH (none_lbl
, spec
))
83 files
= DINFO_STRUCT_FILE_NONE
;
84 else if (MATCH (any_lbl
, spec
))
85 files
= DINFO_STRUCT_FILE_ANY
;
86 else if (MATCH (sys_lbl
, spec
))
87 files
= DINFO_STRUCT_FILE_SYS
;
88 else if (MATCH (base_lbl
, spec
))
89 files
= DINFO_STRUCT_FILE_BASE
;
92 "argument %qs to %<-femit-struct-debug-detailed%> "
96 /* Effect the specification. */
97 if (usage
== DINFO_USAGE_NUM_ENUMS
)
101 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DFN
] = files
;
102 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
] = files
;
103 opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
] = files
;
107 opts
->x_debug_struct_generic
[DINFO_USAGE_DFN
] = files
;
108 opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
] = files
;
109 opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
] = files
;
115 opts
->x_debug_struct_ordinary
[usage
] = files
;
117 opts
->x_debug_struct_generic
[usage
] = files
;
121 set_struct_debug_option (opts
, loc
, spec
+1);
124 /* No more -femit-struct-debug-detailed specifications.
128 "argument %qs to %<-femit-struct-debug-detailed%> unknown",
130 if (opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
]
131 < opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
]
132 || opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
]
133 < opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
])
135 "%<-femit-struct-debug-detailed=dir:...%> must allow "
136 "at least as much as "
137 "%<-femit-struct-debug-detailed=ind:...%>");
141 /* Strip off a legitimate source ending from the input string NAME of
142 length LEN. Rather than having to know the names used by all of
143 our front ends, we strip off an ending of a period followed by
144 up to fource characters. (C++ uses ".cpp".) */
147 strip_off_ending (char *name
, int len
)
150 for (i
= 2; i
< 5 && len
> i
; i
++)
152 if (name
[len
- i
] == '.')
154 name
[len
- i
] = '\0';
160 /* Find the base name of a path, stripping off both directories and
161 a single final extension. */
163 base_of_path (const char *path
, const char **base_out
)
165 const char *base
= path
;
167 const char *p
= path
;
171 if (IS_DIR_SEPARATOR (c
))
186 /* What to print when a switch has no documentation. */
187 static const char undocumented_msg
[] = N_("This option lacks documentation.");
188 static const char use_diagnosed_msg
[] = N_("Uses of this option are diagnosed.");
190 typedef char *char_p
; /* For DEF_VEC_P. */
192 static void handle_param (struct gcc_options
*opts
,
193 struct gcc_options
*opts_set
, location_t loc
,
195 static void set_debug_level (enum debug_info_type type
, int extended
,
196 const char *arg
, struct gcc_options
*opts
,
197 struct gcc_options
*opts_set
,
199 static void set_fast_math_flags (struct gcc_options
*opts
, int set
);
200 static void decode_d_option (const char *arg
, struct gcc_options
*opts
,
201 location_t loc
, diagnostic_context
*dc
);
202 static void set_unsafe_math_optimizations_flags (struct gcc_options
*opts
,
204 static void enable_warning_as_error (const char *arg
, int value
,
205 unsigned int lang_mask
,
206 const struct cl_option_handlers
*handlers
,
207 struct gcc_options
*opts
,
208 struct gcc_options
*opts_set
,
210 diagnostic_context
*dc
);
212 /* Handle a back-end option; arguments and return value as for
216 target_handle_option (struct gcc_options
*opts
,
217 struct gcc_options
*opts_set
,
218 const struct cl_decoded_option
*decoded
,
219 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
221 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
222 diagnostic_context
*dc
, void (*) (void))
224 gcc_assert (dc
== global_dc
);
225 gcc_assert (kind
== DK_UNSPECIFIED
);
226 return targetm_common
.handle_option (opts
, opts_set
, decoded
, loc
);
229 /* Add comma-separated strings to a char_p vector. */
232 add_comma_separated_to_vector (void **pvec
, const char *arg
)
238 vec
<char_p
> *v
= (vec
<char_p
> *) *pvec
;
240 vec_check_alloc (v
, 1);
242 /* We never free this string. */
255 v
->safe_push (token_start
);
258 if (*r
== '\\' && r
[1] == ',')
268 if (*token_start
!= '\0')
269 v
->safe_push (token_start
);
274 /* Initialize opts_obstack. */
277 init_opts_obstack (void)
279 gcc_obstack_init (&opts_obstack
);
282 /* Initialize OPTS and OPTS_SET before using them in parsing options. */
285 init_options_struct (struct gcc_options
*opts
, struct gcc_options
*opts_set
)
287 size_t num_params
= get_num_compiler_params ();
289 /* Ensure that opts_obstack has already been initialized by the time
290 that we initialize any gcc_options instances (PR jit/68446). */
291 gcc_assert (opts_obstack
.chunk_size
> 0);
293 *opts
= global_options_init
;
296 memset (opts_set
, 0, sizeof (*opts_set
));
298 opts
->x_param_values
= XNEWVEC (int, num_params
);
301 opts_set
->x_param_values
= XCNEWVEC (int, num_params
);
303 init_param_values (opts
->x_param_values
);
305 /* Initialize whether `char' is signed. */
306 opts
->x_flag_signed_char
= DEFAULT_SIGNED_CHAR
;
307 /* Set this to a special "uninitialized" value. The actual default
308 is set after target options have been processed. */
309 opts
->x_flag_short_enums
= 2;
311 /* Initialize target_flags before default_options_optimization
312 so the latter can modify it. */
313 opts
->x_target_flags
= targetm_common
.default_target_flags
;
315 /* Some targets have ABI-specified unwind tables. */
316 opts
->x_flag_unwind_tables
= targetm_common
.unwind_tables_default
;
318 /* Some targets have other target-specific initialization. */
319 targetm_common
.option_init_struct (opts
);
322 /* Release any allocations owned by OPTS. */
325 finalize_options_struct (struct gcc_options
*opts
)
327 XDELETEVEC (opts
->x_param_values
);
330 /* If indicated by the optimization level LEVEL (-Os if SIZE is set,
331 -Ofast if FAST is set, -Og if DEBUG is set), apply the option DEFAULT_OPT
332 to OPTS and OPTS_SET, diagnostic context DC, location LOC, with language
333 mask LANG_MASK and option handlers HANDLERS. */
336 maybe_default_option (struct gcc_options
*opts
,
337 struct gcc_options
*opts_set
,
338 const struct default_options
*default_opt
,
339 int level
, bool size
, bool fast
, bool debug
,
340 unsigned int lang_mask
,
341 const struct cl_option_handlers
*handlers
,
343 diagnostic_context
*dc
)
345 const struct cl_option
*option
= &cl_options
[default_opt
->opt_index
];
349 gcc_assert (level
== 2);
351 gcc_assert (level
== 3);
353 gcc_assert (level
== 1);
355 switch (default_opt
->levels
)
361 case OPT_LEVELS_0_ONLY
:
362 enabled
= (level
== 0);
365 case OPT_LEVELS_1_PLUS
:
366 enabled
= (level
>= 1);
369 case OPT_LEVELS_1_PLUS_SPEED_ONLY
:
370 enabled
= (level
>= 1 && !size
&& !debug
);
373 case OPT_LEVELS_1_PLUS_NOT_DEBUG
:
374 enabled
= (level
>= 1 && !debug
);
377 case OPT_LEVELS_2_PLUS
:
378 enabled
= (level
>= 2);
381 case OPT_LEVELS_2_PLUS_SPEED_ONLY
:
382 enabled
= (level
>= 2 && !size
&& !debug
);
385 case OPT_LEVELS_3_PLUS
:
386 enabled
= (level
>= 3);
389 case OPT_LEVELS_3_PLUS_AND_SIZE
:
390 enabled
= (level
>= 3 || size
);
393 case OPT_LEVELS_SIZE
:
397 case OPT_LEVELS_FAST
:
401 case OPT_LEVELS_NONE
:
407 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
408 default_opt
->arg
, default_opt
->value
,
409 lang_mask
, DK_UNSPECIFIED
, loc
,
411 else if (default_opt
->arg
== NULL
412 && !option
->cl_reject_negative
)
413 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
414 default_opt
->arg
, !default_opt
->value
,
415 lang_mask
, DK_UNSPECIFIED
, loc
,
419 /* As indicated by the optimization level LEVEL (-Os if SIZE is set,
420 -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
421 OPTS and OPTS_SET, diagnostic context DC, location LOC, with
422 language mask LANG_MASK and option handlers HANDLERS. */
425 maybe_default_options (struct gcc_options
*opts
,
426 struct gcc_options
*opts_set
,
427 const struct default_options
*default_opts
,
428 int level
, bool size
, bool fast
, bool debug
,
429 unsigned int lang_mask
,
430 const struct cl_option_handlers
*handlers
,
432 diagnostic_context
*dc
)
436 for (i
= 0; default_opts
[i
].levels
!= OPT_LEVELS_NONE
; i
++)
437 maybe_default_option (opts
, opts_set
, &default_opts
[i
],
438 level
, size
, fast
, debug
,
439 lang_mask
, handlers
, loc
, dc
);
442 /* Table of options enabled by default at different levels.
443 Please keep this list sorted by level and alphabetized within
444 each level; this makes it easier to keep the documentation
447 static const struct default_options default_options_table
[] =
449 /* -O1 and -Og optimizations. */
450 { OPT_LEVELS_1_PLUS
, OPT_fcombine_stack_adjustments
, NULL
, 1 },
451 { OPT_LEVELS_1_PLUS
, OPT_fcompare_elim
, NULL
, 1 },
452 { OPT_LEVELS_1_PLUS
, OPT_fcprop_registers
, NULL
, 1 },
453 { OPT_LEVELS_1_PLUS
, OPT_fdefer_pop
, NULL
, 1 },
454 { OPT_LEVELS_1_PLUS
, OPT_fforward_propagate
, NULL
, 1 },
455 { OPT_LEVELS_1_PLUS
, OPT_fguess_branch_probability
, NULL
, 1 },
456 { OPT_LEVELS_1_PLUS
, OPT_fipa_profile
, NULL
, 1 },
457 { OPT_LEVELS_1_PLUS
, OPT_fipa_pure_const
, NULL
, 1 },
458 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference
, NULL
, 1 },
459 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference_addressable
, NULL
, 1 },
460 { OPT_LEVELS_1_PLUS
, OPT_fmerge_constants
, NULL
, 1 },
461 { OPT_LEVELS_1_PLUS
, OPT_fomit_frame_pointer
, NULL
, 1 },
462 { OPT_LEVELS_1_PLUS
, OPT_freorder_blocks
, NULL
, 1 },
463 { OPT_LEVELS_1_PLUS
, OPT_fshrink_wrap
, NULL
, 1 },
464 { OPT_LEVELS_1_PLUS
, OPT_fsplit_wide_types
, NULL
, 1 },
465 { OPT_LEVELS_1_PLUS
, OPT_ftree_builtin_call_dce
, NULL
, 1 },
466 { OPT_LEVELS_1_PLUS
, OPT_ftree_ccp
, NULL
, 1 },
467 { OPT_LEVELS_1_PLUS
, OPT_ftree_ch
, NULL
, 1 },
468 { OPT_LEVELS_1_PLUS
, OPT_ftree_coalesce_vars
, NULL
, 1 },
469 { OPT_LEVELS_1_PLUS
, OPT_ftree_copy_prop
, NULL
, 1 },
470 { OPT_LEVELS_1_PLUS
, OPT_ftree_dce
, NULL
, 1 },
471 { OPT_LEVELS_1_PLUS
, OPT_ftree_dominator_opts
, NULL
, 1 },
472 { OPT_LEVELS_1_PLUS
, OPT_ftree_fre
, NULL
, 1 },
473 { OPT_LEVELS_1_PLUS
, OPT_ftree_sink
, NULL
, 1 },
474 { OPT_LEVELS_1_PLUS
, OPT_ftree_slsr
, NULL
, 1 },
475 { OPT_LEVELS_1_PLUS
, OPT_ftree_ter
, NULL
, 1 },
477 /* -O1 (and not -Og) optimizations. */
478 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fbranch_count_reg
, NULL
, 1 },
480 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fdelayed_branch
, NULL
, 1 },
482 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fdse
, NULL
, 1 },
483 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion
, NULL
, 1 },
484 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion2
, NULL
, 1 },
485 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_finline_functions_called_once
, NULL
, 1 },
486 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_invariants
, NULL
, 1 },
487 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fssa_phiopt
, NULL
, 1 },
488 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_bit_ccp
, NULL
, 1 },
489 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_dse
, NULL
, 1 },
490 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_pta
, NULL
, 1 },
491 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_sra
, NULL
, 1 },
493 /* -O2 and -Os optimizations. */
494 { OPT_LEVELS_2_PLUS
, OPT_fcaller_saves
, NULL
, 1 },
495 { OPT_LEVELS_2_PLUS
, OPT_fcode_hoisting
, NULL
, 1 },
496 { OPT_LEVELS_2_PLUS
, OPT_fcrossjumping
, NULL
, 1 },
497 { OPT_LEVELS_2_PLUS
, OPT_fcse_follow_jumps
, NULL
, 1 },
498 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize
, NULL
, 1 },
499 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize_speculatively
, NULL
, 1 },
500 { OPT_LEVELS_2_PLUS
, OPT_fexpensive_optimizations
, NULL
, 1 },
501 { OPT_LEVELS_2_PLUS
, OPT_ffinite_loops
, NULL
, 1 },
502 { OPT_LEVELS_2_PLUS
, OPT_fgcse
, NULL
, 1 },
503 { OPT_LEVELS_2_PLUS
, OPT_fhoist_adjacent_loads
, NULL
, 1 },
504 { OPT_LEVELS_2_PLUS
, OPT_findirect_inlining
, NULL
, 1 },
505 { OPT_LEVELS_2_PLUS
, OPT_finline_small_functions
, NULL
, 1 },
506 { OPT_LEVELS_2_PLUS
, OPT_fipa_bit_cp
, NULL
, 1 },
507 { OPT_LEVELS_2_PLUS
, OPT_fipa_cp
, NULL
, 1 },
508 { OPT_LEVELS_2_PLUS
, OPT_fipa_icf
, NULL
, 1 },
509 { OPT_LEVELS_2_PLUS
, OPT_fipa_ra
, NULL
, 1 },
510 { OPT_LEVELS_2_PLUS
, OPT_fipa_sra
, NULL
, 1 },
511 { OPT_LEVELS_2_PLUS
, OPT_fipa_vrp
, NULL
, 1 },
512 { OPT_LEVELS_2_PLUS
, OPT_fisolate_erroneous_paths_dereference
, NULL
, 1 },
513 { OPT_LEVELS_2_PLUS
, OPT_flra_remat
, NULL
, 1 },
514 { OPT_LEVELS_2_PLUS
, OPT_foptimize_sibling_calls
, NULL
, 1 },
515 { OPT_LEVELS_2_PLUS
, OPT_fpartial_inlining
, NULL
, 1 },
516 { OPT_LEVELS_2_PLUS
, OPT_fpeephole2
, NULL
, 1 },
517 { OPT_LEVELS_2_PLUS
, OPT_freorder_functions
, NULL
, 1 },
518 { OPT_LEVELS_2_PLUS
, OPT_frerun_cse_after_loop
, NULL
, 1 },
519 #ifdef INSN_SCHEDULING
520 { OPT_LEVELS_2_PLUS
, OPT_fschedule_insns2
, NULL
, 1 },
522 { OPT_LEVELS_2_PLUS
, OPT_fstrict_aliasing
, NULL
, 1 },
523 { OPT_LEVELS_2_PLUS
, OPT_fstore_merging
, NULL
, 1 },
524 { OPT_LEVELS_2_PLUS
, OPT_fthread_jumps
, NULL
, 1 },
525 { OPT_LEVELS_2_PLUS
, OPT_ftree_pre
, NULL
, 1 },
526 { OPT_LEVELS_2_PLUS
, OPT_ftree_switch_conversion
, NULL
, 1 },
527 { OPT_LEVELS_2_PLUS
, OPT_ftree_tail_merge
, NULL
, 1 },
528 { OPT_LEVELS_2_PLUS
, OPT_ftree_vrp
, NULL
, 1 },
529 { OPT_LEVELS_2_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_CHEAP
},
531 /* -O2 and -Os optimizations. */
532 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_functions
, NULL
, 1 },
533 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_jumps
, NULL
, 1 },
534 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_labels
, NULL
, 1 },
535 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_loops
, NULL
, 1 },
536 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_foptimize_strlen
, NULL
, 1 },
537 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_freorder_blocks_algorithm_
, NULL
,
538 REORDER_BLOCKS_ALGORITHM_STC
},
539 #ifdef INSN_SCHEDULING
540 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
541 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_fschedule_insns
, NULL
, 1 },
544 /* -O3 and -Os optimizations. */
545 /* Inlining of functions reducing size is a good idea with -Os
546 regardless of them being declared inline. */
547 { OPT_LEVELS_3_PLUS_AND_SIZE
, OPT_finline_functions
, NULL
, 1 },
549 /* -O3 optimizations. */
550 { OPT_LEVELS_3_PLUS
, OPT_fgcse_after_reload
, NULL
, 1 },
551 { OPT_LEVELS_3_PLUS
, OPT_fipa_cp_clone
, NULL
, 1 },
552 { OPT_LEVELS_3_PLUS
, OPT_floop_interchange
, NULL
, 1 },
553 { OPT_LEVELS_3_PLUS
, OPT_floop_unroll_and_jam
, NULL
, 1 },
554 { OPT_LEVELS_3_PLUS
, OPT_fpeel_loops
, NULL
, 1 },
555 { OPT_LEVELS_3_PLUS
, OPT_fpredictive_commoning
, NULL
, 1 },
556 { OPT_LEVELS_3_PLUS
, OPT_fsplit_loops
, NULL
, 1 },
557 { OPT_LEVELS_3_PLUS
, OPT_fsplit_paths
, NULL
, 1 },
558 { OPT_LEVELS_2_PLUS
, OPT_ftree_loop_distribute_patterns
, NULL
, 1 },
559 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribution
, NULL
, 1 },
560 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_vectorize
, NULL
, 1 },
561 { OPT_LEVELS_3_PLUS
, OPT_ftree_partial_pre
, NULL
, 1 },
562 { OPT_LEVELS_3_PLUS
, OPT_ftree_slp_vectorize
, NULL
, 1 },
563 { OPT_LEVELS_3_PLUS
, OPT_funswitch_loops
, NULL
, 1 },
564 { OPT_LEVELS_3_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_DYNAMIC
},
565 { OPT_LEVELS_3_PLUS
, OPT_fversion_loops_for_strides
, NULL
, 1 },
567 /* -Ofast adds optimizations to -O3. */
568 { OPT_LEVELS_FAST
, OPT_ffast_math
, NULL
, 1 },
570 { OPT_LEVELS_NONE
, 0, NULL
, 0 }
573 /* Default the options in OPTS and OPTS_SET based on the optimization
574 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
576 default_options_optimization (struct gcc_options
*opts
,
577 struct gcc_options
*opts_set
,
578 struct cl_decoded_option
*decoded_options
,
579 unsigned int decoded_options_count
,
581 unsigned int lang_mask
,
582 const struct cl_option_handlers
*handlers
,
583 diagnostic_context
*dc
)
587 bool openacc_mode
= false;
589 /* Scan to see what optimization level has been specified. That will
590 determine the default value of many flags. */
591 for (i
= 1; i
< decoded_options_count
; i
++)
593 struct cl_decoded_option
*opt
= &decoded_options
[i
];
594 switch (opt
->opt_index
)
597 if (*opt
->arg
== '\0')
599 opts
->x_optimize
= 1;
600 opts
->x_optimize_size
= 0;
601 opts
->x_optimize_fast
= 0;
602 opts
->x_optimize_debug
= 0;
606 const int optimize_val
= integral_argument (opt
->arg
);
607 if (optimize_val
== -1)
608 error_at (loc
, "argument to %<-O%> should be a non-negative "
609 "integer, %<g%>, %<s%> or %<fast%>");
612 opts
->x_optimize
= optimize_val
;
613 if ((unsigned int) opts
->x_optimize
> 255)
614 opts
->x_optimize
= 255;
615 opts
->x_optimize_size
= 0;
616 opts
->x_optimize_fast
= 0;
617 opts
->x_optimize_debug
= 0;
623 opts
->x_optimize_size
= 1;
625 /* Optimizing for size forces optimize to be 2. */
626 opts
->x_optimize
= 2;
627 opts
->x_optimize_fast
= 0;
628 opts
->x_optimize_debug
= 0;
632 /* -Ofast only adds flags to -O3. */
633 opts
->x_optimize_size
= 0;
634 opts
->x_optimize
= 3;
635 opts
->x_optimize_fast
= 1;
636 opts
->x_optimize_debug
= 0;
640 /* -Og selects optimization level 1. */
641 opts
->x_optimize_size
= 0;
642 opts
->x_optimize
= 1;
643 opts
->x_optimize_fast
= 0;
644 opts
->x_optimize_debug
= 1;
653 /* Ignore other options in this prescan. */
658 maybe_default_options (opts
, opts_set
, default_options_table
,
659 opts
->x_optimize
, opts
->x_optimize_size
,
660 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
661 lang_mask
, handlers
, loc
, dc
);
663 /* -O2 param settings. */
664 opt2
= (opts
->x_optimize
>= 2);
667 && !opts_set
->x_flag_ipa_pta
)
668 opts
->x_flag_ipa_pta
= true;
670 /* Track fields in field-sensitive alias analysis. */
671 maybe_set_param_value
672 (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
,
673 opt2
? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
),
674 opts
->x_param_values
, opts_set
->x_param_values
);
676 /* For -O1 only do loop invariant motion for very small loops. */
677 maybe_set_param_value
678 (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
,
679 opt2
? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
)
680 : default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
) / 10,
681 opts
->x_param_values
, opts_set
->x_param_values
);
683 /* For -O1 reduce the maximum number of active local stores for RTL DSE
684 since this can consume huge amounts of memory (PR89115). */
685 maybe_set_param_value
686 (PARAM_MAX_DSE_ACTIVE_LOCAL_STORES
,
687 opt2
? default_param_value (PARAM_MAX_DSE_ACTIVE_LOCAL_STORES
)
688 : default_param_value (PARAM_MAX_DSE_ACTIVE_LOCAL_STORES
) / 10,
689 opts
->x_param_values
, opts_set
->x_param_values
);
691 /* At -Ofast, allow store motion to introduce potential race conditions. */
692 maybe_set_param_value
693 (PARAM_ALLOW_STORE_DATA_RACES
,
694 opts
->x_optimize_fast
? 1
695 : default_param_value (PARAM_ALLOW_STORE_DATA_RACES
),
696 opts
->x_param_values
, opts_set
->x_param_values
);
698 if (opts
->x_optimize_size
)
699 /* We want to crossjump as much as possible. */
700 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
, 1,
701 opts
->x_param_values
, opts_set
->x_param_values
);
703 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
,
704 default_param_value (PARAM_MIN_CROSSJUMP_INSNS
),
705 opts
->x_param_values
, opts_set
->x_param_values
);
707 /* Restrict the amount of work combine does at -Og while retaining
708 most of its useful transforms. */
709 if (opts
->x_optimize_debug
)
710 maybe_set_param_value (PARAM_MAX_COMBINE_INSNS
, 2,
711 opts
->x_param_values
, opts_set
->x_param_values
);
713 /* Allow default optimizations to be specified on a per-machine basis. */
714 maybe_default_options (opts
, opts_set
,
715 targetm_common
.option_optimization_table
,
716 opts
->x_optimize
, opts
->x_optimize_size
,
717 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
718 lang_mask
, handlers
, loc
, dc
);
721 /* Control IPA optimizations based on different live patching LEVEL. */
723 control_options_for_live_patching (struct gcc_options
*opts
,
724 struct gcc_options
*opts_set
,
725 enum live_patching_level level
,
728 gcc_assert (level
> LIVE_PATCHING_NONE
);
732 case LIVE_PATCHING_INLINE_ONLY_STATIC
:
733 if (opts_set
->x_flag_ipa_cp_clone
&& opts
->x_flag_ipa_cp_clone
)
735 "%<-fipa-cp-clone%> is incompatible with "
736 "%<-flive-patching=inline-only-static%>");
738 opts
->x_flag_ipa_cp_clone
= 0;
740 if (opts_set
->x_flag_ipa_sra
&& opts
->x_flag_ipa_sra
)
742 "%<-fipa-sra%> is incompatible with "
743 "%<-flive-patching=inline-only-static%>");
745 opts
->x_flag_ipa_sra
= 0;
747 if (opts_set
->x_flag_partial_inlining
&& opts
->x_flag_partial_inlining
)
749 "%<-fpartial-inlining%> is incompatible with "
750 "%<-flive-patching=inline-only-static%>");
752 opts
->x_flag_partial_inlining
= 0;
754 if (opts_set
->x_flag_ipa_cp
&& opts
->x_flag_ipa_cp
)
756 "%<-fipa-cp%> is incompatible with "
757 "%<-flive-patching=inline-only-static%>");
759 opts
->x_flag_ipa_cp
= 0;
762 case LIVE_PATCHING_INLINE_CLONE
:
763 /* live patching should disable whole-program optimization. */
764 if (opts_set
->x_flag_whole_program
&& opts
->x_flag_whole_program
)
766 "%<-fwhole-program%> is incompatible with "
767 "%<-flive-patching=inline-only-static|inline-clone%>");
769 opts
->x_flag_whole_program
= 0;
771 /* visibility change should be excluded by !flag_whole_program
772 && !in_lto_p && !flag_ipa_cp_clone && !flag_ipa_sra
773 && !flag_partial_inlining. */
775 if (opts_set
->x_flag_ipa_pta
&& opts
->x_flag_ipa_pta
)
777 "%<-fipa-pta%> is incompatible with "
778 "%<-flive-patching=inline-only-static|inline-clone%>");
780 opts
->x_flag_ipa_pta
= 0;
782 if (opts_set
->x_flag_ipa_reference
&& opts
->x_flag_ipa_reference
)
784 "%<-fipa-reference%> is incompatible with "
785 "%<-flive-patching=inline-only-static|inline-clone%>");
787 opts
->x_flag_ipa_reference
= 0;
789 if (opts_set
->x_flag_ipa_ra
&& opts
->x_flag_ipa_ra
)
791 "%<-fipa-ra%> is incompatible with "
792 "%<-flive-patching=inline-only-static|inline-clone%>");
794 opts
->x_flag_ipa_ra
= 0;
796 if (opts_set
->x_flag_ipa_icf
&& opts
->x_flag_ipa_icf
)
798 "%<-fipa-icf%> is incompatible with "
799 "%<-flive-patching=inline-only-static|inline-clone%>");
801 opts
->x_flag_ipa_icf
= 0;
803 if (opts_set
->x_flag_ipa_icf_functions
&& opts
->x_flag_ipa_icf_functions
)
805 "%<-fipa-icf-functions%> is incompatible with "
806 "%<-flive-patching=inline-only-static|inline-clone%>");
808 opts
->x_flag_ipa_icf_functions
= 0;
810 if (opts_set
->x_flag_ipa_icf_variables
&& opts
->x_flag_ipa_icf_variables
)
812 "%<-fipa-icf-variables%> is incompatible with "
813 "%<-flive-patching=inline-only-static|inline-clone%>");
815 opts
->x_flag_ipa_icf_variables
= 0;
817 if (opts_set
->x_flag_ipa_bit_cp
&& opts
->x_flag_ipa_bit_cp
)
819 "%<-fipa-bit-cp%> is incompatible with "
820 "%<-flive-patching=inline-only-static|inline-clone%>");
822 opts
->x_flag_ipa_bit_cp
= 0;
824 if (opts_set
->x_flag_ipa_vrp
&& opts
->x_flag_ipa_vrp
)
826 "%<-fipa-vrp%> is incompatible with "
827 "%<-flive-patching=inline-only-static|inline-clone%>");
829 opts
->x_flag_ipa_vrp
= 0;
831 if (opts_set
->x_flag_ipa_pure_const
&& opts
->x_flag_ipa_pure_const
)
833 "%<-fipa-pure-const%> is incompatible with "
834 "%<-flive-patching=inline-only-static|inline-clone%>");
836 opts
->x_flag_ipa_pure_const
= 0;
838 /* FIXME: disable unreachable code removal. */
840 /* discovery of functions/variables with no address taken. */
841 if (opts_set
->x_flag_ipa_reference_addressable
842 && opts
->x_flag_ipa_reference_addressable
)
844 "%<-fipa-reference-addressable%> is incompatible with "
845 "%<-flive-patching=inline-only-static|inline-clone%>");
847 opts
->x_flag_ipa_reference_addressable
= 0;
849 /* ipa stack alignment propagation. */
850 if (opts_set
->x_flag_ipa_stack_alignment
851 && opts
->x_flag_ipa_stack_alignment
)
853 "%<-fipa-stack-alignment%> is incompatible with "
854 "%<-flive-patching=inline-only-static|inline-clone%>");
856 opts
->x_flag_ipa_stack_alignment
= 0;
863 /* --help option argument if set. */
864 vec
<const char *> help_option_arguments
;
867 /* After all options at LOC have been read into OPTS and OPTS_SET,
868 finalize settings of those options and diagnose incompatible
871 finish_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
874 enum unwind_info_type ui_except
;
876 if (opts
->x_dump_base_name
877 && ! opts
->x_dump_base_name_prefixed
)
879 const char *sep
= opts
->x_dump_base_name
;
882 if (IS_DIR_SEPARATOR (*sep
))
886 /* If dump_base_path contains subdirectories, don't prepend
888 else if (opts
->x_dump_dir_name
)
889 /* We have a DUMP_DIR_NAME, prepend that. */
890 opts
->x_dump_base_name
= opts_concat (opts
->x_dump_dir_name
,
891 opts
->x_dump_base_name
, NULL
);
892 else if (opts
->x_aux_base_name
893 && strcmp (opts
->x_aux_base_name
, HOST_BIT_BUCKET
) != 0)
894 /* AUX_BASE_NAME is set and is not the bit bucket. If it
895 contains a directory component, prepend those directories.
896 Typically this places things in the same directory as the
899 const char *aux_base
;
901 base_of_path (opts
->x_aux_base_name
, &aux_base
);
902 if (opts
->x_aux_base_name
!= aux_base
)
904 int dir_len
= aux_base
- opts
->x_aux_base_name
;
905 char *new_dump_base_name
906 = XOBNEWVEC (&opts_obstack
, char,
907 strlen (opts
->x_dump_base_name
) + dir_len
+ 1);
909 /* Copy directory component from OPTS->X_AUX_BASE_NAME. */
910 memcpy (new_dump_base_name
, opts
->x_aux_base_name
, dir_len
);
911 /* Append existing OPTS->X_DUMP_BASE_NAME. */
912 strcpy (new_dump_base_name
+ dir_len
, opts
->x_dump_base_name
);
913 opts
->x_dump_base_name
= new_dump_base_name
;
917 /* It is definitely prefixed now. */
918 opts
->x_dump_base_name_prefixed
= true;
921 /* Handle related options for unit-at-a-time, toplevel-reorder, and
923 if (!opts
->x_flag_unit_at_a_time
)
925 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
926 error_at (loc
, "section anchors must be disabled when unit-at-a-time "
928 opts
->x_flag_section_anchors
= 0;
929 if (opts
->x_flag_toplevel_reorder
== 1)
930 error_at (loc
, "toplevel reorder must be disabled when unit-at-a-time "
932 opts
->x_flag_toplevel_reorder
= 0;
935 /* -fself-test depends on the state of the compiler prior to
936 compiling anything. Ideally it should be run on an empty source
937 file. However, in case we get run with actual source, assume
938 -fsyntax-only which will inhibit any compiler initialization
939 which may confuse the self tests. */
940 if (opts
->x_flag_self_test
)
941 opts
->x_flag_syntax_only
= 1;
943 if (opts
->x_flag_tm
&& opts
->x_flag_non_call_exceptions
)
944 sorry ("transactional memory is not supported with non-call exceptions");
946 /* Unless the user has asked for section anchors, we disable toplevel
947 reordering at -O0 to disable transformations that might be surprising
948 to end users and to get -fno-toplevel-reorder tested. */
949 if (!opts
->x_optimize
950 && opts
->x_flag_toplevel_reorder
== 2
951 && !(opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
))
953 opts
->x_flag_toplevel_reorder
= 0;
954 opts
->x_flag_section_anchors
= 0;
956 if (!opts
->x_flag_toplevel_reorder
)
958 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
959 error_at (loc
, "section anchors must be disabled when toplevel reorder"
961 opts
->x_flag_section_anchors
= 0;
964 if (!opts
->x_flag_opts_finished
)
966 /* We initialize opts->x_flag_pie to -1 so that targets can set a
968 if (opts
->x_flag_pie
== -1)
970 /* We initialize opts->x_flag_pic to -1 so that we can tell if
971 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
972 if (opts
->x_flag_pic
== -1)
973 opts
->x_flag_pie
= DEFAULT_FLAG_PIE
;
975 opts
->x_flag_pie
= 0;
977 /* If -fPIE or -fpie is used, turn on PIC. */
978 if (opts
->x_flag_pie
)
979 opts
->x_flag_pic
= opts
->x_flag_pie
;
980 else if (opts
->x_flag_pic
== -1)
981 opts
->x_flag_pic
= 0;
982 if (opts
->x_flag_pic
&& !opts
->x_flag_pie
)
983 opts
->x_flag_shlib
= 1;
984 opts
->x_flag_opts_finished
= true;
987 /* We initialize opts->x_flag_stack_protect to -1 so that targets
988 can set a default value. */
989 if (opts
->x_flag_stack_protect
== -1)
990 opts
->x_flag_stack_protect
= DEFAULT_FLAG_SSP
;
992 if (opts
->x_optimize
== 0)
994 /* Inlining does not work if not optimizing,
995 so force it not to be done. */
996 opts
->x_warn_inline
= 0;
997 opts
->x_flag_no_inline
= 1;
1000 /* The optimization to partition hot and cold basic blocks into separate
1001 sections of the .o and executable files does not work (currently)
1002 with exception handling. This is because there is no support for
1003 generating unwind info. If opts->x_flag_exceptions is turned on
1004 we need to turn off the partitioning optimization. */
1006 ui_except
= targetm_common
.except_unwind_info (opts
);
1008 if (opts
->x_flag_exceptions
1009 && opts
->x_flag_reorder_blocks_and_partition
1010 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1012 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1014 "%<-freorder-blocks-and-partition%> does not work "
1015 "with exceptions on this architecture");
1016 opts
->x_flag_reorder_blocks_and_partition
= 0;
1017 opts
->x_flag_reorder_blocks
= 1;
1020 /* If user requested unwind info, then turn off the partitioning
1023 if (opts
->x_flag_unwind_tables
1024 && !targetm_common
.unwind_tables_default
1025 && opts
->x_flag_reorder_blocks_and_partition
1026 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1028 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1030 "%<-freorder-blocks-and-partition%> does not support "
1031 "unwind info on this architecture");
1032 opts
->x_flag_reorder_blocks_and_partition
= 0;
1033 opts
->x_flag_reorder_blocks
= 1;
1036 /* If the target requested unwind info, then turn off the partitioning
1037 optimization with a different message. Likewise, if the target does not
1038 support named sections. */
1040 if (opts
->x_flag_reorder_blocks_and_partition
1041 && (!targetm_common
.have_named_sections
1042 || (opts
->x_flag_unwind_tables
1043 && targetm_common
.unwind_tables_default
1044 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
1046 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1048 "%<-freorder-blocks-and-partition%> does not work "
1049 "on this architecture");
1050 opts
->x_flag_reorder_blocks_and_partition
= 0;
1051 opts
->x_flag_reorder_blocks
= 1;
1055 /* Pipelining of outer loops is only possible when general pipelining
1056 capabilities are requested. */
1057 if (!opts
->x_flag_sel_sched_pipelining
)
1058 opts
->x_flag_sel_sched_pipelining_outer_loops
= 0;
1060 if (opts
->x_flag_conserve_stack
)
1062 maybe_set_param_value (PARAM_LARGE_STACK_FRAME
, 100,
1063 opts
->x_param_values
, opts_set
->x_param_values
);
1064 maybe_set_param_value (PARAM_STACK_FRAME_GROWTH
, 40,
1065 opts
->x_param_values
, opts_set
->x_param_values
);
1068 if (opts
->x_flag_lto
)
1071 opts
->x_flag_generate_lto
= 1;
1073 /* When generating IL, do not operate in whole-program mode.
1074 Otherwise, symbols will be privatized too early, causing link
1076 opts
->x_flag_whole_program
= 0;
1078 error_at (loc
, "LTO support has not been enabled in this configuration");
1080 if (!opts
->x_flag_fat_lto_objects
1081 && (!HAVE_LTO_PLUGIN
1082 || (opts_set
->x_flag_use_linker_plugin
1083 && !opts
->x_flag_use_linker_plugin
)))
1085 if (opts_set
->x_flag_fat_lto_objects
)
1086 error_at (loc
, "%<-fno-fat-lto-objects%> are supported only with "
1088 opts
->x_flag_fat_lto_objects
= 1;
1091 /* -gsplit-dwarf isn't compatible with LTO, see PR88389. */
1092 if (opts
->x_dwarf_split_debug_info
)
1094 inform (loc
, "%<-gsplit-dwarf%> is not supported with LTO,"
1096 opts
->x_dwarf_split_debug_info
= 0;
1100 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
1101 default value if they choose based on other options. */
1102 if (opts
->x_flag_split_stack
== -1)
1103 opts
->x_flag_split_stack
= 0;
1104 else if (opts
->x_flag_split_stack
)
1106 if (!targetm_common
.supports_split_stack (true, opts
))
1108 error_at (loc
, "%<-fsplit-stack%> is not supported by "
1109 "this compiler configuration");
1110 opts
->x_flag_split_stack
= 0;
1114 /* If stack splitting is turned on, and the user did not explicitly
1115 request function partitioning, turn off partitioning, as it
1116 confuses the linker when trying to handle partitioned split-stack
1117 code that calls a non-split-stack functions. But if partitioning
1118 was turned on explicitly just hope for the best. */
1119 if (opts
->x_flag_split_stack
1120 && opts
->x_flag_reorder_blocks_and_partition
1121 && !opts_set
->x_flag_reorder_blocks_and_partition
)
1122 opts
->x_flag_reorder_blocks_and_partition
= 0;
1124 if (opts
->x_flag_reorder_blocks_and_partition
1125 && !opts_set
->x_flag_reorder_functions
)
1126 opts
->x_flag_reorder_functions
= 1;
1128 /* Tune vectorization related parametees according to cost model. */
1129 if (opts
->x_flag_vect_cost_model
== VECT_COST_MODEL_CHEAP
)
1131 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS
,
1132 6, opts
->x_param_values
, opts_set
->x_param_values
);
1133 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS
,
1134 0, opts
->x_param_values
, opts_set
->x_param_values
);
1135 maybe_set_param_value (PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT
,
1136 0, opts
->x_param_values
, opts_set
->x_param_values
);
1139 /* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
1141 if ((!opts
->x_flag_tree_loop_vectorize
&& !opts
->x_flag_tree_slp_vectorize
)
1142 || !opts
->x_flag_tree_loop_if_convert
)
1143 maybe_set_param_value (PARAM_MAX_STORES_TO_SINK
, 0,
1144 opts
->x_param_values
, opts_set
->x_param_values
);
1146 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
1147 if (opts
->x_dwarf_split_debug_info
)
1148 opts
->x_debug_generate_pub_sections
= 2;
1150 if ((opts
->x_flag_sanitize
1151 & (SANITIZE_USER_ADDRESS
| SANITIZE_KERNEL_ADDRESS
)) == 0)
1153 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_COMPARE
)
1155 "%<-fsanitize=pointer-compare%> must be combined with "
1156 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1157 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_SUBTRACT
)
1159 "%<-fsanitize=pointer-subtract%> must be combined with "
1160 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1163 /* Userspace and kernel ASan conflict with each other. */
1164 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
1165 && (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
))
1167 "%<-fsanitize=address%> is incompatible with "
1168 "%<-fsanitize=kernel-address%>");
1170 /* And with TSan. */
1171 if ((opts
->x_flag_sanitize
& SANITIZE_ADDRESS
)
1172 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
1174 "%<-fsanitize=address%> and %<-fsanitize=kernel-address%> "
1175 "are incompatible with %<-fsanitize=thread%>");
1177 if ((opts
->x_flag_sanitize
& SANITIZE_LEAK
)
1178 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
1180 "%<-fsanitize=leak%> is incompatible with %<-fsanitize=thread%>");
1182 /* Check error recovery for -fsanitize-recover option. */
1183 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1184 if ((opts
->x_flag_sanitize_recover
& sanitizer_opts
[i
].flag
)
1185 && !sanitizer_opts
[i
].can_recover
)
1186 error_at (loc
, "%<-fsanitize-recover=%s%> is not supported",
1187 sanitizer_opts
[i
].name
);
1189 /* When instrumenting the pointers, we don't want to remove
1190 the null pointer checks. */
1191 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
1192 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
1193 opts
->x_flag_delete_null_pointer_checks
= 0;
1195 /* Aggressive compiler optimizations may cause false negatives. */
1196 if (opts
->x_flag_sanitize
& ~(SANITIZE_LEAK
| SANITIZE_UNREACHABLE
))
1197 opts
->x_flag_aggressive_loop_optimizations
= 0;
1199 /* Enable -fsanitize-address-use-after-scope if address sanitizer is
1201 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
1202 && !opts_set
->x_flag_sanitize_address_use_after_scope
)
1203 opts
->x_flag_sanitize_address_use_after_scope
= true;
1205 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1207 if (opts
->x_flag_sanitize_address_use_after_scope
)
1209 if (opts
->x_flag_stack_reuse
!= SR_NONE
1210 && opts_set
->x_flag_stack_reuse
!= SR_NONE
)
1212 "%<-fsanitize-address-use-after-scope%> requires "
1213 "%<-fstack-reuse=none%> option");
1215 opts
->x_flag_stack_reuse
= SR_NONE
;
1218 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
) && opts
->x_flag_tm
)
1219 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1221 if ((opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) && opts
->x_flag_tm
)
1222 sorry ("transactional memory is not supported with "
1223 "%<-fsanitize=kernel-address%>");
1225 /* Currently live patching is not support for LTO. */
1226 if (opts
->x_flag_live_patching
&& opts
->x_flag_lto
)
1227 sorry ("live patching is not supported with LTO");
1229 /* Currently vtable verification is not supported for LTO */
1230 if (opts
->x_flag_vtable_verify
&& opts
->x_flag_lto
)
1231 sorry ("vtable verification is not supported with LTO");
1233 /* Control IPA optimizations based on different -flive-patching level. */
1234 if (opts
->x_flag_live_patching
)
1236 control_options_for_live_patching (opts
, opts_set
,
1237 opts
->x_flag_live_patching
,
1242 #define LEFT_COLUMN 27
1244 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1245 followed by word-wrapped HELP in a second column. */
1247 wrap_help (const char *help
,
1249 unsigned int item_width
,
1250 unsigned int columns
)
1252 unsigned int col_width
= LEFT_COLUMN
;
1253 unsigned int remaining
, room
, len
;
1255 remaining
= strlen (help
);
1259 room
= columns
- 3 - MAX (col_width
, item_width
);
1268 for (i
= 0; help
[i
]; i
++)
1270 if (i
>= room
&& len
!= remaining
)
1274 else if ((help
[i
] == '-' || help
[i
] == '/')
1275 && help
[i
+ 1] != ' '
1276 && i
> 0 && ISALPHA (help
[i
- 1]))
1281 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1283 while (help
[len
] == ' ')
1291 /* Data structure used to print list of valid option values. */
1293 class option_help_tuple
1296 option_help_tuple (int code
, vec
<const char *> values
):
1297 m_code (code
), m_values (values
)
1300 /* Code of an option. */
1303 /* List of possible values. */
1304 vec
<const char *> m_values
;
1307 /* Print help for a specific front-end, etc. */
1309 print_filtered_help (unsigned int include_flags
,
1310 unsigned int exclude_flags
,
1311 unsigned int any_flags
,
1312 unsigned int columns
,
1313 struct gcc_options
*opts
,
1314 unsigned int lang_mask
)
1319 bool displayed
= false;
1322 if (include_flags
== CL_PARAMS
)
1324 for (i
= 0; i
< LAST_PARAM
; i
++)
1326 const char *param
= compiler_params
[i
].option
;
1328 help
= compiler_params
[i
].help
;
1329 if (help
== NULL
|| *help
== '\0')
1331 if (exclude_flags
& CL_UNDOCUMENTED
)
1333 help
= undocumented_msg
;
1336 /* Get the translation. */
1339 if (!opts
->x_quiet_flag
)
1341 snprintf (new_help
, sizeof (new_help
),
1342 _("default %d minimum %d maximum %d"),
1343 compiler_params
[i
].default_value
,
1344 compiler_params
[i
].min_value
,
1345 compiler_params
[i
].max_value
);
1348 wrap_help (help
, param
, strlen (param
), columns
);
1354 if (!opts
->x_help_printed
)
1355 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1357 if (!opts
->x_help_enum_printed
)
1358 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1360 auto_vec
<option_help_tuple
> help_tuples
;
1362 for (i
= 0; i
< cl_options_count
; i
++)
1364 const struct cl_option
*option
= cl_options
+ i
;
1369 if (include_flags
== 0
1370 || ((option
->flags
& include_flags
) != include_flags
))
1372 if ((option
->flags
& any_flags
) == 0)
1376 /* Skip unwanted switches. */
1377 if ((option
->flags
& exclude_flags
) != 0)
1380 /* The driver currently prints its own help text. */
1381 if ((option
->flags
& CL_DRIVER
) != 0
1382 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1383 | CL_COMMON
| CL_TARGET
)) == 0)
1387 /* Skip switches that have already been printed. */
1388 if (opts
->x_help_printed
[i
])
1391 opts
->x_help_printed
[i
] = true;
1393 help
= option
->help
;
1396 if (exclude_flags
& CL_UNDOCUMENTED
)
1399 help
= undocumented_msg
;
1402 if (option
->alias_target
< N_OPTS
1403 && cl_options
[option
->alias_target
].help
)
1405 if (help
== undocumented_msg
)
1407 /* For undocumented options that are aliases for other options
1408 that are documented, point the reader to the other option in
1409 preference of the former. */
1410 snprintf (new_help
, sizeof new_help
,
1411 _("Same as %s. Use the latter option instead."),
1412 cl_options
[option
->alias_target
].opt_text
);
1416 /* For documented options with aliases, mention the aliased
1417 option's name for reference. */
1418 snprintf (new_help
, sizeof new_help
,
1419 _("%s Same as %s."),
1420 help
, cl_options
[option
->alias_target
].opt_text
);
1426 if (option
->warn_message
)
1428 /* Mention that the use of the option will trigger a warning. */
1429 if (help
== new_help
)
1430 snprintf (new_help
+ strlen (new_help
),
1431 sizeof new_help
- strlen (new_help
),
1432 " %s", _(use_diagnosed_msg
));
1434 snprintf (new_help
, sizeof new_help
,
1435 "%s %s", help
, _(use_diagnosed_msg
));
1440 /* Get the translation. */
1443 /* Find the gap between the name of the
1444 option and its descriptive text. */
1445 tab
= strchr (help
, '\t');
1454 opt
= option
->opt_text
;
1458 /* With the -Q option enabled we change the descriptive text associated
1459 with an option to be an indication of its current setting. */
1460 if (!opts
->x_quiet_flag
)
1462 void *flag_var
= option_flag_var (i
, opts
);
1464 if (len
< (LEFT_COLUMN
+ 2))
1465 strcpy (new_help
, "\t\t");
1467 strcpy (new_help
, "\t");
1469 /* Set to print whether the option is enabled or disabled,
1470 or, if it's an alias for another option, the name of
1471 the aliased option. */
1472 bool print_state
= false;
1474 if (flag_var
!= NULL
1475 && option
->var_type
!= CLVC_DEFER
)
1477 /* If OPTION is only available for a specific subset
1478 of languages other than this one, mention them. */
1479 bool avail_for_lang
= true;
1480 if (unsigned langset
= option
->flags
& CL_LANG_ALL
)
1482 if (!(langset
& lang_mask
))
1484 avail_for_lang
= false;
1485 strcat (new_help
, _("[available in "));
1486 for (unsigned i
= 0, n
= 0; (1U << i
) < CL_LANG_ALL
; ++i
)
1487 if (langset
& (1U << i
))
1490 strcat (new_help
, ", ");
1491 strcat (new_help
, lang_names
[i
]);
1493 strcat (new_help
, "]");
1496 if (!avail_for_lang
)
1497 ; /* Print nothing else if the option is not available
1498 in the current language. */
1499 else if (option
->flags
& CL_JOINED
)
1501 if (option
->var_type
== CLVC_STRING
)
1503 if (* (const char **) flag_var
!= NULL
)
1504 snprintf (new_help
+ strlen (new_help
),
1505 sizeof (new_help
) - strlen (new_help
),
1506 "%s", * (const char **) flag_var
);
1508 else if (option
->var_type
== CLVC_ENUM
)
1510 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1512 const char *arg
= NULL
;
1514 value
= e
->get (flag_var
);
1515 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1517 arg
= _("[default]");
1518 snprintf (new_help
+ strlen (new_help
),
1519 sizeof (new_help
) - strlen (new_help
),
1524 if (option
->cl_host_wide_int
)
1525 sprintf (new_help
+ strlen (new_help
),
1526 _("%llu bytes"), (unsigned long long)
1527 *(unsigned HOST_WIDE_INT
*) flag_var
);
1529 sprintf (new_help
+ strlen (new_help
),
1530 "%i", * (int *) flag_var
);
1537 /* When there is no argument, print the option state only
1538 if the option takes no argument. */
1539 print_state
= !(option
->flags
& CL_JOINED
);
1543 if (option
->alias_target
< N_OPTS
1544 && option
->alias_target
!= OPT_SPECIAL_warn_removed
1545 && option
->alias_target
!= OPT_SPECIAL_ignore
1546 && option
->alias_target
!= OPT_SPECIAL_input_file
1547 && option
->alias_target
!= OPT_SPECIAL_program_name
1548 && option
->alias_target
!= OPT_SPECIAL_unknown
)
1550 const struct cl_option
*target
1551 = &cl_options
[option
->alias_target
];
1552 sprintf (new_help
+ strlen (new_help
), "%s%s",
1554 option
->alias_arg
? option
->alias_arg
: "");
1556 else if (option
->alias_target
== OPT_SPECIAL_ignore
)
1557 strcat (new_help
, ("[ignored]"));
1560 /* Print the state for an on/off option. */
1561 int ena
= option_enabled (i
, lang_mask
, opts
);
1563 strcat (new_help
, _("[enabled]"));
1565 strcat (new_help
, _("[disabled]"));
1572 if (option
->range_max
!= -1)
1575 snprintf (b
, sizeof (b
), "<%d,%d>", option
->range_min
,
1577 opt
= concat (opt
, b
, NULL
);
1581 wrap_help (help
, opt
, len
, columns
);
1584 if (option
->var_type
== CLVC_ENUM
1585 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1586 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1589 vec
<const char *> option_values
1590 = targetm_common
.get_valid_option_values (i
, NULL
);
1591 if (!option_values
.is_empty ())
1592 help_tuples
.safe_push (option_help_tuple (i
, option_values
));
1598 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1601 printf (_(" No options with the desired characteristics were found\n"));
1606 /* PR 31349: Tell the user how to see all of the
1607 options supported by a specific front end. */
1608 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1609 if ((1U << i
) & langs
)
1610 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1611 lang_names
[i
], lang_names
[i
]);
1615 else if (! displayed
)
1616 printf (_(" All options with the desired characteristics have already been displayed\n"));
1620 /* Print details of enumerated option arguments, if those
1621 enumerations have help text headings provided. If no help text
1622 is provided, presume that the possible values are listed in the
1623 help text for the relevant options. */
1624 for (i
= 0; i
< cl_enums_count
; i
++)
1626 unsigned int j
, pos
;
1628 if (opts
->x_help_enum_printed
[i
] != 1)
1630 if (cl_enums
[i
].help
== NULL
)
1632 printf (" %s\n ", _(cl_enums
[i
].help
));
1634 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1636 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1638 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1640 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1650 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1655 opts
->x_help_enum_printed
[i
] = 2;
1658 for (unsigned i
= 0; i
< help_tuples
.length (); i
++)
1660 const struct cl_option
*option
= cl_options
+ help_tuples
[i
].m_code
;
1661 printf (_(" Known valid arguments for %s option:\n "),
1663 for (unsigned j
= 0; j
< help_tuples
[i
].m_values
.length (); j
++)
1664 printf (" %s", help_tuples
[i
].m_values
[j
]);
1669 /* Display help for a specified type of option.
1670 The options must have ALL of the INCLUDE_FLAGS set
1671 ANY of the flags in the ANY_FLAGS set
1672 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1673 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1675 print_specific_help (unsigned int include_flags
,
1676 unsigned int exclude_flags
,
1677 unsigned int any_flags
,
1678 struct gcc_options
*opts
,
1679 unsigned int lang_mask
)
1681 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1682 const char * description
= NULL
;
1683 const char * descrip_extra
= "";
1687 /* Sanity check: Make sure that we do not have more
1688 languages than we have bits available to enumerate them. */
1689 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1691 /* If we have not done so already, obtain
1692 the desired maximum width of the output. */
1693 if (opts
->x_help_columns
== 0)
1695 opts
->x_help_columns
= get_terminal_width ();
1696 if (opts
->x_help_columns
== INT_MAX
)
1697 /* Use a reasonable default. */
1698 opts
->x_help_columns
= 80;
1701 /* Decide upon the title for the options that we are going to display. */
1702 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1704 switch (flag
& include_flags
)
1711 description
= _("The following options are target specific");
1714 description
= _("The following options control compiler warning messages");
1716 case CL_OPTIMIZATION
:
1717 description
= _("The following options control optimizations");
1720 description
= _("The following options are language-independent");
1723 description
= _("The --param option recognizes the following as parameters");
1726 if (i
>= cl_lang_count
)
1728 if (exclude_flags
& all_langs_mask
)
1729 description
= _("The following options are specific to just the language ");
1731 description
= _("The following options are supported by the language ");
1732 descrip_extra
= lang_names
[i
];
1737 if (description
== NULL
)
1741 if (include_flags
& CL_UNDOCUMENTED
)
1742 description
= _("The following options are not documented");
1743 else if (include_flags
& CL_SEPARATE
)
1744 description
= _("The following options take separate arguments");
1745 else if (include_flags
& CL_JOINED
)
1746 description
= _("The following options take joined arguments");
1749 internal_error ("unrecognized %<include_flags 0x%x%> passed "
1750 "to %<print_specific_help%>",
1757 if (any_flags
& all_langs_mask
)
1758 description
= _("The following options are language-related");
1760 description
= _("The following options are language-independent");
1764 printf ("%s%s:\n", description
, descrip_extra
);
1765 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
1766 opts
->x_help_columns
, opts
, lang_mask
);
1769 /* Enable FDO-related flags. */
1772 enable_fdo_optimizations (struct gcc_options
*opts
,
1773 struct gcc_options
*opts_set
,
1776 if (!opts_set
->x_flag_branch_probabilities
)
1777 opts
->x_flag_branch_probabilities
= value
;
1778 if (!opts_set
->x_flag_profile_values
)
1779 opts
->x_flag_profile_values
= value
;
1780 if (!opts_set
->x_flag_unroll_loops
)
1781 opts
->x_flag_unroll_loops
= value
;
1782 if (!opts_set
->x_flag_peel_loops
)
1783 opts
->x_flag_peel_loops
= value
;
1784 if (!opts_set
->x_flag_tracer
)
1785 opts
->x_flag_tracer
= value
;
1786 if (!opts_set
->x_flag_value_profile_transformations
)
1787 opts
->x_flag_value_profile_transformations
= value
;
1788 if (!opts_set
->x_flag_inline_functions
)
1789 opts
->x_flag_inline_functions
= value
;
1790 if (!opts_set
->x_flag_ipa_cp
)
1791 opts
->x_flag_ipa_cp
= value
;
1792 if (!opts_set
->x_flag_ipa_cp_clone
1793 && value
&& opts
->x_flag_ipa_cp
)
1794 opts
->x_flag_ipa_cp_clone
= value
;
1795 if (!opts_set
->x_flag_ipa_bit_cp
1796 && value
&& opts
->x_flag_ipa_cp
)
1797 opts
->x_flag_ipa_bit_cp
= value
;
1798 if (!opts_set
->x_flag_predictive_commoning
)
1799 opts
->x_flag_predictive_commoning
= value
;
1800 if (!opts_set
->x_flag_split_loops
)
1801 opts
->x_flag_split_loops
= value
;
1802 if (!opts_set
->x_flag_unswitch_loops
)
1803 opts
->x_flag_unswitch_loops
= value
;
1804 if (!opts_set
->x_flag_gcse_after_reload
)
1805 opts
->x_flag_gcse_after_reload
= value
;
1806 if (!opts_set
->x_flag_tree_loop_vectorize
)
1807 opts
->x_flag_tree_loop_vectorize
= value
;
1808 if (!opts_set
->x_flag_tree_slp_vectorize
)
1809 opts
->x_flag_tree_slp_vectorize
= value
;
1810 if (!opts_set
->x_flag_version_loops_for_strides
)
1811 opts
->x_flag_version_loops_for_strides
= value
;
1812 if (!opts_set
->x_flag_vect_cost_model
)
1813 opts
->x_flag_vect_cost_model
= VECT_COST_MODEL_DYNAMIC
;
1814 if (!opts_set
->x_flag_tree_loop_distribute_patterns
)
1815 opts
->x_flag_tree_loop_distribute_patterns
= value
;
1816 if (!opts_set
->x_flag_loop_interchange
)
1817 opts
->x_flag_loop_interchange
= value
;
1818 if (!opts_set
->x_flag_unroll_jam
)
1819 opts
->x_flag_unroll_jam
= value
;
1820 if (!opts_set
->x_flag_tree_loop_distribution
)
1821 opts
->x_flag_tree_loop_distribution
= value
;
1824 /* -f{,no-}sanitize{,-recover}= suboptions. */
1825 const struct sanitizer_opts_s sanitizer_opts
[] =
1827 #define SANITIZER_OPT(name, flags, recover) \
1828 { #name, flags, sizeof #name - 1, recover }
1829 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true),
1830 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
1832 SANITIZER_OPT (pointer
-compare
, SANITIZE_POINTER_COMPARE
, true),
1833 SANITIZER_OPT (pointer
-subtract
, SANITIZE_POINTER_SUBTRACT
, true),
1834 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false),
1835 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false),
1836 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true),
1837 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true),
1838 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true),
1839 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true),
1840 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true),
1841 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false),
1842 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true),
1843 SANITIZER_OPT (return, SANITIZE_RETURN
, false),
1844 SANITIZER_OPT (null
, SANITIZE_NULL
, true),
1845 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true),
1846 SANITIZER_OPT (bool, SANITIZE_BOOL
, true),
1847 SANITIZER_OPT (enum, SANITIZE_ENUM
, true),
1848 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true),
1849 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true),
1850 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true),
1851 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true),
1852 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true),
1853 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true),
1854 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
1856 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true),
1857 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true),
1858 SANITIZER_OPT (pointer
-overflow
, SANITIZE_POINTER_OVERFLOW
, true),
1859 SANITIZER_OPT (builtin
, SANITIZE_BUILTIN
, true),
1860 SANITIZER_OPT (all
, ~0U, true),
1861 #undef SANITIZER_OPT
1862 { NULL
, 0U, 0UL, false }
1865 /* -f{,no-}sanitize-coverage= suboptions. */
1866 const struct sanitizer_opts_s coverage_sanitizer_opts
[] =
1868 #define COVERAGE_SANITIZER_OPT(name, flags) \
1869 { #name, flags, sizeof #name - 1, true }
1870 COVERAGE_SANITIZER_OPT (trace
-pc
, SANITIZE_COV_TRACE_PC
),
1871 COVERAGE_SANITIZER_OPT (trace
-cmp
, SANITIZE_COV_TRACE_CMP
),
1872 #undef COVERAGE_SANITIZER_OPT
1873 { NULL
, 0U, 0UL, false }
1876 /* A struct for describing a run of chars within a string. */
1878 class string_fragment
1881 string_fragment (const char *start
, size_t len
)
1882 : m_start (start
), m_len (len
) {}
1884 const char *m_start
;
1888 /* Specialization of edit_distance_traits for string_fragment,
1889 for use by get_closest_sanitizer_option. */
1892 struct edit_distance_traits
<const string_fragment
&>
1894 static size_t get_length (const string_fragment
&fragment
)
1896 return fragment
.m_len
;
1899 static const char *get_string (const string_fragment
&fragment
)
1901 return fragment
.m_start
;
1905 /* Given ARG, an unrecognized sanitizer option, return the best
1906 matching sanitizer option, or NULL if there isn't one.
1907 OPTS is array of candidate sanitizer options.
1908 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or
1909 OPT_fsanitize_coverage_.
1910 VALUE is non-zero for the regular form of the option, zero
1911 for the "no-" form (e.g. "-fno-sanitize-recover="). */
1914 get_closest_sanitizer_option (const string_fragment
&arg
,
1915 const struct sanitizer_opts_s
*opts
,
1916 enum opt_code code
, int value
)
1918 best_match
<const string_fragment
&, const char*> bm (arg
);
1919 for (int i
= 0; opts
[i
].name
!= NULL
; ++i
)
1921 /* -fsanitize=all is not valid, so don't offer it. */
1922 if (code
== OPT_fsanitize_
1923 && opts
[i
].flag
== ~0U
1927 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
1928 don't offer the non-recoverable options. */
1929 if (code
== OPT_fsanitize_recover_
1930 && !opts
[i
].can_recover
1934 bm
.consider (opts
[i
].name
);
1936 return bm
.get_best_meaningful_candidate ();
1939 /* Parse comma separated sanitizer suboptions from P for option SCODE,
1940 adjust previous FLAGS and return new ones. If COMPLAIN is false,
1941 don't issue diagnostics. */
1944 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
1945 unsigned int flags
, int value
, bool complain
)
1947 enum opt_code code
= (enum opt_code
) scode
;
1949 const struct sanitizer_opts_s
*opts
;
1950 if (code
== OPT_fsanitize_coverage_
)
1951 opts
= coverage_sanitizer_opts
;
1953 opts
= sanitizer_opts
;
1959 const char *comma
= strchr (p
, ',');
1971 /* Check to see if the string matches an option class name. */
1972 for (i
= 0; opts
[i
].name
!= NULL
; ++i
)
1973 if (len
== opts
[i
].len
&& memcmp (p
, opts
[i
].name
, len
) == 0)
1975 /* Handle both -fsanitize and -fno-sanitize cases. */
1976 if (value
&& opts
[i
].flag
== ~0U)
1978 if (code
== OPT_fsanitize_
)
1981 error_at (loc
, "%<-fsanitize=all%> option is not valid");
1984 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
1985 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
1989 /* Do not enable -fsanitize-recover=unreachable and
1990 -fsanitize-recover=return if -fsanitize-recover=undefined
1992 if (code
== OPT_fsanitize_recover_
1993 && opts
[i
].flag
== SANITIZE_UNDEFINED
)
1994 flags
|= (SANITIZE_UNDEFINED
1995 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
1997 flags
|= opts
[i
].flag
;
2000 flags
&= ~opts
[i
].flag
;
2005 if (! found
&& complain
)
2008 = get_closest_sanitizer_option (string_fragment (p
, len
),
2012 if (code
== OPT_fsanitize_recover_
)
2013 suffix
= "-recover";
2014 else if (code
== OPT_fsanitize_coverage_
)
2015 suffix
= "-coverage";
2021 "unrecognized argument to %<-f%ssanitize%s=%> "
2022 "option: %q.*s; did you mean %qs?",
2024 suffix
, (int) len
, p
, hint
);
2027 "unrecognized argument to %<-f%ssanitize%s=%> option: "
2028 "%q.*s", value
? "" : "no-",
2029 suffix
, (int) len
, p
);
2039 /* Parse string values of no_sanitize attribute passed in VALUE.
2040 Values are separated with comma. */
2043 parse_no_sanitize_attribute (char *value
)
2045 unsigned int flags
= 0;
2047 char *q
= strtok (value
, ",");
2051 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
2052 if (strcmp (sanitizer_opts
[i
].name
, q
) == 0)
2054 flags
|= sanitizer_opts
[i
].flag
;
2055 if (sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
2056 flags
|= SANITIZE_UNDEFINED_NONDEFAULT
;
2060 if (sanitizer_opts
[i
].name
== NULL
)
2061 warning (OPT_Wattributes
,
2062 "%qs attribute directive ignored", q
);
2064 q
= strtok (NULL
, ",");
2070 /* Parse -falign-NAME format for a FLAG value. Return individual
2071 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
2072 set, print error message at LOC location. */
2075 parse_and_check_align_values (const char *flag
,
2077 auto_vec
<unsigned> &result_values
,
2081 char *str
= xstrdup (flag
);
2082 for (char *p
= strtok (str
, ":"); p
; p
= strtok (NULL
, ":"))
2085 int v
= strtol (p
, &end
, 10);
2086 if (*end
!= '\0' || v
< 0)
2089 error_at (loc
, "invalid arguments for %<-falign-%s%> option: %qs",
2095 result_values
.safe_push ((unsigned)v
);
2100 /* Check that we have a correct number of values. */
2101 if (result_values
.is_empty () || result_values
.length () > 4)
2104 error_at (loc
, "invalid number of arguments for %<-falign-%s%> "
2105 "option: %qs", name
, flag
);
2109 for (unsigned i
= 0; i
< result_values
.length (); i
++)
2110 if (result_values
[i
] > MAX_CODE_ALIGN_VALUE
)
2113 error_at (loc
, "%<-falign-%s%> is not between 0 and %d",
2114 name
, MAX_CODE_ALIGN_VALUE
);
2121 /* Check that alignment value FLAG for -falign-NAME is valid at a given
2125 check_alignment_argument (location_t loc
, const char *flag
, const char *name
)
2127 auto_vec
<unsigned> align_result
;
2128 parse_and_check_align_values (flag
, name
, align_result
, true, loc
);
2131 /* Print help when OPT__help_ is set. */
2134 print_help (struct gcc_options
*opts
, unsigned int lang_mask
,
2135 const char *help_option_argument
)
2137 const char *a
= help_option_argument
;
2138 unsigned int include_flags
= 0;
2139 /* Note - by default we include undocumented options when listing
2140 specific classes. If you only want to see documented options
2141 then add ",^undocumented" to the --help= option. E.g.:
2143 --help=target,^undocumented */
2144 unsigned int exclude_flags
= 0;
2146 if (lang_mask
== CL_DRIVER
)
2149 /* Walk along the argument string, parsing each word in turn.
2151 arg = [^]{word}[,{arg}]
2152 word = {optimizers|target|warnings|undocumented|
2153 params|common|<language>} */
2163 { "optimizers", CL_OPTIMIZATION
},
2164 { "target", CL_TARGET
},
2165 { "warnings", CL_WARNING
},
2166 { "undocumented", CL_UNDOCUMENTED
},
2167 { "params", CL_PARAMS
},
2168 { "joined", CL_JOINED
},
2169 { "separate", CL_SEPARATE
},
2170 { "common", CL_COMMON
},
2173 unsigned int *pflags
;
2175 unsigned int lang_flag
, specific_flag
;
2184 error ("missing argument to %qs", "--help=^");
2187 pflags
= &exclude_flags
;
2190 pflags
= &include_flags
;
2192 comma
= strchr (a
, ',');
2203 /* Check to see if the string matches an option class name. */
2204 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
2205 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
2207 specific_flag
= specifics
[i
].flag
;
2211 /* Check to see if the string matches a language name.
2212 Note - we rely upon the alpha-sorted nature of the entries in
2213 the lang_names array, specifically that shorter names appear
2214 before their longer variants. (i.e. C before C++). That way
2215 when we are attempting to match --help=c for example we will
2216 match with C first and not C++. */
2217 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
2218 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
2220 lang_flag
= 1U << i
;
2224 if (specific_flag
!= 0)
2227 *pflags
|= specific_flag
;
2230 /* The option's argument matches both the start of a
2231 language name and the start of an option class name.
2232 We have a special case for when the user has
2233 specified "--help=c", but otherwise we have to issue
2235 if (strncasecmp (a
, "c", len
) == 0)
2236 *pflags
|= lang_flag
;
2239 "%<--help%> argument %q.*s is ambiguous, "
2240 "please be more specific",
2244 else if (lang_flag
!= 0)
2245 *pflags
|= lang_flag
;
2248 "unrecognized argument to %<--help=%> option: %q.*s",
2257 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
2261 /* Handle target- and language-independent options. Return zero to
2262 generate an "unknown option" message. Only options that need
2263 extra handling need to be listed here; if you simply want
2264 DECODED->value assigned to a variable, it happens automatically. */
2267 common_handle_option (struct gcc_options
*opts
,
2268 struct gcc_options
*opts_set
,
2269 const struct cl_decoded_option
*decoded
,
2270 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
2272 const struct cl_option_handlers
*handlers
,
2273 diagnostic_context
*dc
,
2274 void (*target_option_override_hook
) (void))
2276 size_t scode
= decoded
->opt_index
;
2277 const char *arg
= decoded
->arg
;
2278 HOST_WIDE_INT value
= decoded
->value
;
2279 enum opt_code code
= (enum opt_code
) scode
;
2281 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
2286 handle_param (opts
, opts_set
, loc
, arg
);
2291 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
2292 unsigned int undoc_mask
;
2295 if (lang_mask
== CL_DRIVER
)
2298 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
2301 target_option_override_hook ();
2302 /* First display any single language specific options. */
2303 for (i
= 0; i
< cl_lang_count
; i
++)
2305 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
2307 /* Next display any multi language specific options. */
2308 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
2309 /* Then display any remaining, non-language options. */
2310 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
2312 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
2313 opts
->x_exit_after_options
= true;
2317 case OPT__target_help
:
2318 if (lang_mask
== CL_DRIVER
)
2321 target_option_override_hook ();
2322 print_specific_help (CL_TARGET
, CL_UNDOCUMENTED
, 0, opts
, lang_mask
);
2323 opts
->x_exit_after_options
= true;
2328 help_option_arguments
.safe_push (arg
);
2329 opts
->x_exit_after_options
= true;
2334 if (lang_mask
== CL_DRIVER
)
2337 opts
->x_exit_after_options
= true;
2340 case OPT__completion_
:
2343 case OPT_fsanitize_
:
2344 opts
->x_flag_sanitize
2345 = parse_sanitizer_options (arg
, loc
, code
,
2346 opts
->x_flag_sanitize
, value
, true);
2348 /* Kernel ASan implies normal ASan but does not yet support
2350 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
2352 maybe_set_param_value (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD
,
2353 0, opts
->x_param_values
,
2354 opts_set
->x_param_values
);
2355 maybe_set_param_value (PARAM_ASAN_GLOBALS
, 0, opts
->x_param_values
,
2356 opts_set
->x_param_values
);
2357 maybe_set_param_value (PARAM_ASAN_STACK
, 0, opts
->x_param_values
,
2358 opts_set
->x_param_values
);
2359 maybe_set_param_value (PARAM_ASAN_PROTECT_ALLOCAS
, 0,
2360 opts
->x_param_values
,
2361 opts_set
->x_param_values
);
2362 maybe_set_param_value (PARAM_ASAN_USE_AFTER_RETURN
, 0,
2363 opts
->x_param_values
,
2364 opts_set
->x_param_values
);
2368 case OPT_fsanitize_recover_
:
2369 opts
->x_flag_sanitize_recover
2370 = parse_sanitizer_options (arg
, loc
, code
,
2371 opts
->x_flag_sanitize_recover
, value
, true);
2374 case OPT_fasan_shadow_offset_
:
2378 case OPT_fsanitize_address_use_after_scope
:
2379 opts
->x_flag_sanitize_address_use_after_scope
= value
;
2382 case OPT_fsanitize_recover
:
2384 opts
->x_flag_sanitize_recover
2385 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)
2386 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2388 opts
->x_flag_sanitize_recover
2389 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2392 case OPT_fsanitize_coverage_
:
2393 opts
->x_flag_sanitize_coverage
2394 = parse_sanitizer_options (arg
, loc
, code
,
2395 opts
->x_flag_sanitize_coverage
, value
, true);
2402 /* Currently handled in a prescan. */
2406 dc
->warning_as_error_requested
= value
;
2410 if (lang_mask
== CL_DRIVER
)
2413 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
2414 opts
, opts_set
, loc
, dc
);
2417 case OPT_Wfatal_errors
:
2418 dc
->fatal_errors
= value
;
2421 case OPT_Wstack_usage_
:
2422 opts
->x_flag_stack_usage_info
= value
!= -1;
2425 case OPT_Wstrict_aliasing
:
2426 set_Wstrict_aliasing (opts
, value
);
2429 case OPT_Wstrict_overflow
:
2430 opts
->x_warn_strict_overflow
= (value
2431 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2435 case OPT_Wsystem_headers
:
2436 dc
->dc_warn_system_headers
= value
;
2440 opts
->x_flag_gen_aux_info
= 1;
2443 case OPT_auxbase_strip
:
2445 char *tmp
= xstrdup (arg
);
2446 strip_off_ending (tmp
, strlen (tmp
));
2448 opts
->x_aux_base_name
= tmp
;
2455 decode_d_option (arg
, opts
, loc
, dc
);
2458 case OPT_fcall_used_
:
2459 case OPT_fcall_saved_
:
2467 case OPT_fdbg_cnt_list
:
2469 opts
->x_exit_after_options
= true;
2472 case OPT_fdebug_prefix_map_
:
2473 case OPT_ffile_prefix_map_
:
2477 case OPT_fdiagnostics_show_location_
:
2478 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2481 case OPT_fdiagnostics_show_caret
:
2482 dc
->show_caret
= value
;
2485 case OPT_fdiagnostics_show_labels
:
2486 dc
->show_labels_p
= value
;
2489 case OPT_fdiagnostics_show_line_numbers
:
2490 dc
->show_line_numbers_p
= value
;
2493 case OPT_fdiagnostics_color_
:
2494 diagnostic_color_init (dc
, value
);
2497 case OPT_fdiagnostics_format_
:
2498 diagnostic_output_format_init (dc
,
2499 (enum diagnostics_output_format
)value
);
2502 case OPT_fdiagnostics_parseable_fixits
:
2503 dc
->parseable_fixits_p
= value
;
2506 case OPT_fdiagnostics_show_option
:
2507 dc
->show_option_requested
= value
;
2510 case OPT_fdiagnostics_minimum_margin_width_
:
2511 dc
->min_margin_width
= value
;
2518 case OPT_ffast_math
:
2519 set_fast_math_flags (opts
, value
);
2522 case OPT_funsafe_math_optimizations
:
2523 set_unsafe_math_optimizations_flags (opts
, value
);
2530 case OPT_finline_limit_
:
2531 set_param_value ("max-inline-insns-single", value
/ 2,
2532 opts
->x_param_values
, opts_set
->x_param_values
);
2533 set_param_value ("max-inline-insns-auto", value
/ 2,
2534 opts
->x_param_values
, opts_set
->x_param_values
);
2537 case OPT_finstrument_functions_exclude_function_list_
:
2538 add_comma_separated_to_vector
2539 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2542 case OPT_finstrument_functions_exclude_file_list_
:
2543 add_comma_separated_to_vector
2544 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2547 case OPT_fmessage_length_
:
2548 pp_set_line_maximum_length (dc
->printer
, value
);
2549 diagnostic_set_caret_max_width (dc
, value
);
2553 case OPT_fopt_info_
:
2559 const char *p
= arg
;
2560 opts
->x_flag_disable_hsa
= true;
2563 const char *comma
= strchr (p
, ',');
2565 if ((strncmp (p
, "disable", 7) == 0)
2566 && (p
[7] == ',' || p
[7] == '\0'))
2568 opts
->x_flag_disable_hsa
= true;
2572 if ((strncmp (p
, "hsa", 3) == 0)
2573 && (p
[3] == ',' || p
[3] == '\0'))
2576 opts
->x_flag_disable_hsa
= false;
2578 sorry ("HSA has not been enabled during configuration");
2588 #ifndef ACCEL_COMPILER
2589 case OPT_foffload_abi_
:
2590 error_at (loc
, "%<-foffload-abi%> option can be specified only for "
2591 "offload compiler");
2595 case OPT_fpack_struct_
:
2596 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2598 "structure alignment must be a small power of two, not %wu",
2601 opts
->x_initial_max_fld_align
= value
;
2605 case OPT_fplugin_arg_
:
2609 case OPT_fprofile_use_
:
2610 opts
->x_profile_data_prefix
= xstrdup (arg
);
2611 opts
->x_flag_profile_use
= true;
2613 /* No break here - do -fprofile-use processing. */
2615 case OPT_fprofile_use
:
2616 enable_fdo_optimizations (opts
, opts_set
, value
);
2617 if (!opts_set
->x_flag_profile_reorder_functions
)
2618 opts
->x_flag_profile_reorder_functions
= value
;
2619 /* Indirect call profiling should do all useful transformations
2620 speculative devirtualization does. */
2621 if (!opts_set
->x_flag_devirtualize_speculatively
2622 && opts
->x_flag_value_profile_transformations
)
2623 opts
->x_flag_devirtualize_speculatively
= false;
2626 case OPT_fauto_profile_
:
2627 opts
->x_auto_profile_file
= xstrdup (arg
);
2628 opts
->x_flag_auto_profile
= true;
2630 /* No break here - do -fauto-profile processing. */
2632 case OPT_fauto_profile
:
2633 enable_fdo_optimizations (opts
, opts_set
, value
);
2634 if (!opts_set
->x_flag_profile_correction
)
2635 opts
->x_flag_profile_correction
= value
;
2636 maybe_set_param_value (
2637 PARAM_EARLY_INLINER_MAX_ITERATIONS
, 10,
2638 opts
->x_param_values
, opts_set
->x_param_values
);
2641 case OPT_fprofile_generate_
:
2642 opts
->x_profile_data_prefix
= xstrdup (arg
);
2644 /* No break here - do -fprofile-generate processing. */
2646 case OPT_fprofile_generate
:
2647 if (!opts_set
->x_profile_arc_flag
)
2648 opts
->x_profile_arc_flag
= value
;
2649 if (!opts_set
->x_flag_profile_values
)
2650 opts
->x_flag_profile_values
= value
;
2651 if (!opts_set
->x_flag_inline_functions
)
2652 opts
->x_flag_inline_functions
= value
;
2653 if (!opts_set
->x_flag_ipa_bit_cp
)
2654 opts
->x_flag_ipa_bit_cp
= value
;
2655 /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
2656 quadratic. Disable the pass until better memory representation
2658 if (!opts_set
->x_flag_ipa_reference
)
2659 opts
->x_flag_ipa_reference
= false;
2662 case OPT_fpatchable_function_entry_
:
2664 char *patch_area_arg
= xstrdup (arg
);
2665 char *comma
= strchr (patch_area_arg
, ',');
2669 function_entry_patch_area_size
=
2670 integral_argument (patch_area_arg
);
2671 function_entry_patch_area_start
=
2672 integral_argument (comma
+ 1);
2676 function_entry_patch_area_size
=
2677 integral_argument (patch_area_arg
);
2678 function_entry_patch_area_start
= 0;
2680 if (function_entry_patch_area_size
< 0
2681 || function_entry_patch_area_start
< 0
2682 || function_entry_patch_area_size
2683 < function_entry_patch_area_start
)
2684 error ("invalid arguments for %<-fpatchable_function_entry%>");
2685 free (patch_area_arg
);
2689 case OPT_ftree_vectorize
:
2690 /* Automatically sets -ftree-loop-vectorize and
2691 -ftree-slp-vectorize. Nothing more to do here. */
2693 case OPT_fshow_column
:
2694 dc
->show_column
= value
;
2697 case OPT_frandom_seed
:
2698 /* The real switch is -fno-random-seed. */
2704 case OPT_frandom_seed_
:
2708 case OPT_fsched_verbose_
:
2709 #ifdef INSN_SCHEDULING
2710 /* Handled with Var in common.opt. */
2716 case OPT_fsched_stalled_insns_
:
2717 opts
->x_flag_sched_stalled_insns
= value
;
2718 if (opts
->x_flag_sched_stalled_insns
== 0)
2719 opts
->x_flag_sched_stalled_insns
= -1;
2722 case OPT_fsched_stalled_insns_dep_
:
2723 opts
->x_flag_sched_stalled_insns_dep
= value
;
2726 case OPT_fstack_check_
:
2727 if (!strcmp (arg
, "no"))
2728 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
2729 else if (!strcmp (arg
, "generic"))
2730 /* This is the old stack checking method. */
2731 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2732 ? FULL_BUILTIN_STACK_CHECK
2733 : GENERIC_STACK_CHECK
;
2734 else if (!strcmp (arg
, "specific"))
2735 /* This is the new stack checking method. */
2736 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2737 ? FULL_BUILTIN_STACK_CHECK
2738 : STACK_CHECK_STATIC_BUILTIN
2739 ? STATIC_BUILTIN_STACK_CHECK
2740 : GENERIC_STACK_CHECK
;
2742 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
2745 case OPT_fstack_limit
:
2746 /* The real switch is -fno-stack-limit. */
2752 case OPT_fstack_limit_register_
:
2753 case OPT_fstack_limit_symbol_
:
2757 case OPT_fstack_usage
:
2758 opts
->x_flag_stack_usage
= value
;
2759 opts
->x_flag_stack_usage_info
= value
!= 0;
2763 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
2768 if (arg
&& strlen (arg
) != 0)
2770 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
2771 "use %<-gdwarf-%s%> for DWARF version "
2772 "or %<-gdwarf%> %<-g%s%> for debug level", arg
, arg
, arg
);
2776 value
= opts
->x_dwarf_version
;
2780 if (value
< 2 || value
> 5)
2781 error_at (loc
, "dwarf version %wu is not supported", value
);
2783 opts
->x_dwarf_version
= value
;
2784 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
2787 case OPT_gsplit_dwarf
:
2788 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, "", opts
, opts_set
,
2793 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
2798 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
, opts
, opts_set
,
2803 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2808 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
, opts
, opts_set
,
2814 /* Handled completely via specs. */
2817 case OPT_pedantic_errors
:
2818 dc
->pedantic_errors
= 1;
2819 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
2821 handlers
, opts
, opts_set
,
2826 opts
->x_flag_lto
= value
? "" : NULL
;
2830 if (strcmp (arg
, "none") != 0
2831 && strcmp (arg
, "jobserver") != 0
2832 && strcmp (arg
, "auto") != 0
2835 "unrecognized argument to %<-flto=%> option: %qs", arg
);
2839 dc
->dc_inhibit_warnings
= true;
2842 case OPT_fmax_errors_
:
2843 dc
->max_errors
= value
;
2846 case OPT_fuse_ld_bfd
:
2847 case OPT_fuse_ld_gold
:
2848 case OPT_fuse_ld_lld
:
2849 case OPT_fuse_linker_plugin
:
2850 /* No-op. Used by the driver and passed to us because it starts with f.*/
2855 opts
->x_flag_trapv
= 0;
2860 opts
->x_flag_wrapv
= 0;
2863 case OPT_fstrict_overflow
:
2864 opts
->x_flag_wrapv
= !value
;
2865 opts
->x_flag_wrapv_pointer
= !value
;
2867 opts
->x_flag_trapv
= 0;
2871 opts
->x_flag_ipa_icf_functions
= value
;
2872 opts
->x_flag_ipa_icf_variables
= value
;
2875 case OPT_falign_loops_
:
2876 check_alignment_argument (loc
, arg
, "loops");
2879 case OPT_falign_jumps_
:
2880 check_alignment_argument (loc
, arg
, "jumps");
2883 case OPT_falign_labels_
:
2884 check_alignment_argument (loc
, arg
, "labels");
2887 case OPT_falign_functions_
:
2888 check_alignment_argument (loc
, arg
, "functions");
2892 /* If the flag was handled in a standard way, assume the lack of
2893 processing here is intentional. */
2894 gcc_assert (option_flag_var (scode
, opts
));
2898 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
2903 /* Handle --param NAME=VALUE. */
2905 handle_param (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2906 location_t loc
, const char *carg
)
2911 arg
= xstrdup (carg
);
2912 equal
= strchr (arg
, '=');
2914 error_at (loc
, "%s: %qs arguments should be of the form NAME=VALUE",
2920 enum compiler_param index
;
2921 if (!find_param (arg
, &index
))
2923 const char *suggestion
= find_param_fuzzy (arg
);
2925 error_at (loc
, "invalid %qs name %qs; did you mean %qs?",
2926 "--param", arg
, suggestion
);
2928 error_at (loc
, "invalid %qs name %qs", "--param", arg
);
2932 if (!param_string_value_p (index
, equal
+ 1, &value
))
2933 value
= integral_argument (equal
+ 1);
2936 error_at (loc
, "invalid %qs value %qs", "--param", equal
+ 1);
2938 set_param_value (arg
, value
,
2939 opts
->x_param_values
, opts_set
->x_param_values
);
2946 /* Used to set the level of strict aliasing warnings in OPTS,
2947 when no level is specified (i.e., when -Wstrict-aliasing, and not
2948 -Wstrict-aliasing=level was given).
2949 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2950 and 0 otherwise. After calling this function, wstrict_aliasing will be
2951 set to the default value of -Wstrict_aliasing=level, currently 3. */
2953 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
2955 gcc_assert (onoff
== 0 || onoff
== 1);
2957 opts
->x_warn_strict_aliasing
= 3;
2959 opts
->x_warn_strict_aliasing
= 0;
2962 /* The following routines are useful in setting all the flags that
2963 -ffast-math and -fno-fast-math imply. */
2965 set_fast_math_flags (struct gcc_options
*opts
, int set
)
2967 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
2969 opts
->x_flag_unsafe_math_optimizations
= set
;
2970 set_unsafe_math_optimizations_flags (opts
, set
);
2972 if (!opts
->frontend_set_flag_finite_math_only
)
2973 opts
->x_flag_finite_math_only
= set
;
2974 if (!opts
->frontend_set_flag_errno_math
)
2975 opts
->x_flag_errno_math
= !set
;
2978 if (opts
->frontend_set_flag_excess_precision
== EXCESS_PRECISION_DEFAULT
)
2979 opts
->x_flag_excess_precision
2980 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
2981 if (!opts
->frontend_set_flag_signaling_nans
)
2982 opts
->x_flag_signaling_nans
= 0;
2983 if (!opts
->frontend_set_flag_rounding_math
)
2984 opts
->x_flag_rounding_math
= 0;
2985 if (!opts
->frontend_set_flag_cx_limited_range
)
2986 opts
->x_flag_cx_limited_range
= 1;
2990 /* When -funsafe-math-optimizations is set the following
2991 flags are set as well. */
2993 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
2995 if (!opts
->frontend_set_flag_trapping_math
)
2996 opts
->x_flag_trapping_math
= !set
;
2997 if (!opts
->frontend_set_flag_signed_zeros
)
2998 opts
->x_flag_signed_zeros
= !set
;
2999 if (!opts
->frontend_set_flag_associative_math
)
3000 opts
->x_flag_associative_math
= set
;
3001 if (!opts
->frontend_set_flag_reciprocal_math
)
3002 opts
->x_flag_reciprocal_math
= set
;
3005 /* Return true iff flags in OPTS are set as if -ffast-math. */
3007 fast_math_flags_set_p (const struct gcc_options
*opts
)
3009 return (!opts
->x_flag_trapping_math
3010 && opts
->x_flag_unsafe_math_optimizations
3011 && opts
->x_flag_finite_math_only
3012 && !opts
->x_flag_signed_zeros
3013 && !opts
->x_flag_errno_math
3014 && opts
->x_flag_excess_precision
== EXCESS_PRECISION_FAST
);
3017 /* Return true iff flags are set as if -ffast-math but using the flags stored
3018 in the struct cl_optimization structure. */
3020 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
3022 return (!opt
->x_flag_trapping_math
3023 && opt
->x_flag_unsafe_math_optimizations
3024 && opt
->x_flag_finite_math_only
3025 && !opt
->x_flag_signed_zeros
3026 && !opt
->x_flag_errno_math
);
3029 /* Handle a debug output -g switch for options OPTS
3030 (OPTS_SET->x_write_symbols storing whether a debug type was passed
3031 explicitly), location LOC. EXTENDED is true or false to support
3032 extended output (2 is special and means "-ggdb" was given). */
3034 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
,
3035 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
3038 opts
->x_use_gnu_debug_info_extensions
= extended
;
3040 if (type
== NO_DEBUG
)
3042 if (opts
->x_write_symbols
== NO_DEBUG
)
3044 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
3048 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
3049 opts
->x_write_symbols
= DWARF2_DEBUG
;
3050 #elif defined DBX_DEBUGGING_INFO
3051 opts
->x_write_symbols
= DBX_DEBUG
;
3055 if (opts
->x_write_symbols
== NO_DEBUG
)
3056 warning_at (loc
, 0, "target system does not support debug output");
3061 /* Does it conflict with an already selected type? */
3062 if (opts_set
->x_write_symbols
!= NO_DEBUG
3063 && opts
->x_write_symbols
!= NO_DEBUG
3064 && type
!= opts
->x_write_symbols
)
3065 error_at (loc
, "debug format %qs conflicts with prior selection",
3066 debug_type_names
[type
]);
3067 opts
->x_write_symbols
= type
;
3068 opts_set
->x_write_symbols
= type
;
3071 /* A debug flag without a level defaults to level 2.
3072 If off or at level 1, set it to level 2, but if already
3073 at level 3, don't lower it. */
3076 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
3077 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3081 int argval
= integral_argument (arg
);
3083 error_at (loc
, "unrecognized debug output level %qs", arg
);
3084 else if (argval
> 3)
3085 error_at (loc
, "debug output level %qs is too high", arg
);
3087 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
3091 /* Arrange to dump core on error for diagnostic context DC. (The
3092 regular error message is still printed first, except in the case of
3096 setup_core_dumping (diagnostic_context
*dc
)
3099 signal (SIGABRT
, SIG_DFL
);
3101 #if defined(HAVE_SETRLIMIT)
3104 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
3105 fatal_error (input_location
, "getting core file size maximum limit: %m");
3106 rlim
.rlim_cur
= rlim
.rlim_max
;
3107 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
3108 fatal_error (input_location
,
3109 "setting core file size limit to maximum: %m");
3112 diagnostic_abort_on_error (dc
);
3115 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
3116 diagnostic context DC. */
3119 decode_d_option (const char *arg
, struct gcc_options
*opts
,
3120 location_t loc
, diagnostic_context
*dc
)
3128 opts
->x_flag_debug_asm
= 1;
3131 opts
->x_flag_print_asm_name
= 1;
3134 opts
->x_flag_dump_rtl_in_asm
= 1;
3135 opts
->x_flag_print_asm_name
= 1;
3138 opts
->x_rtl_dump_and_exit
= 1;
3140 case 'D': /* These are handled by the preprocessor. */
3147 setup_core_dumping (dc
);
3150 opts
->x_flag_dump_all_passed
= true;
3154 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
3159 /* Enable (or disable if VALUE is 0) a warning option ARG (language
3160 mask LANG_MASK, option handlers HANDLERS) as an error for option
3161 structures OPTS and OPTS_SET, diagnostic context DC (possibly
3162 NULL), location LOC. This is used by -Werror=. */
3165 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
3166 const struct cl_option_handlers
*handlers
,
3167 struct gcc_options
*opts
,
3168 struct gcc_options
*opts_set
,
3169 location_t loc
, diagnostic_context
*dc
)
3174 new_option
= XNEWVEC (char, strlen (arg
) + 2);
3175 new_option
[0] = 'W';
3176 strcpy (new_option
+ 1, arg
);
3177 option_index
= find_opt (new_option
, lang_mask
);
3178 if (option_index
== OPT_SPECIAL_unknown
)
3181 const char *hint
= op
.suggest_option (new_option
);
3183 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>;"
3184 " did you mean %<-%s%>?", value
? "" : "no-",
3185 arg
, new_option
, hint
);
3187 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>",
3188 value
? "" : "no-", arg
, new_option
);
3190 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
3191 error_at (loc
, "%<-Werror=%s%>: %<-%s%> is not an option that "
3192 "controls warnings", arg
, new_option
);
3195 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
3196 const char *arg
= NULL
;
3198 if (cl_options
[option_index
].flags
& CL_JOINED
)
3199 arg
= new_option
+ cl_options
[option_index
].opt_len
;
3200 control_warning_option (option_index
, (int) kind
, arg
, value
,
3202 handlers
, opts
, opts_set
, dc
);
3207 /* Return malloced memory for the name of the option OPTION_INDEX
3208 which enabled a diagnostic (context CONTEXT), originally of type
3209 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
3213 option_name (diagnostic_context
*context
, int option_index
,
3214 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
3218 /* A warning classified as an error. */
3219 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
3220 && diag_kind
== DK_ERROR
)
3221 return concat (cl_options
[OPT_Werror_
].opt_text
,
3222 /* Skip over "-W". */
3223 cl_options
[option_index
].opt_text
+ 2,
3225 /* A warning with option. */
3227 return xstrdup (cl_options
[option_index
].opt_text
);
3229 /* A warning without option classified as an error. */
3230 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
3231 || diag_kind
== DK_WARNING
)
3232 && context
->warning_as_error_requested
)
3233 return xstrdup (cl_options
[OPT_Werror
].opt_text
);