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 /* Control IPA optimizations based on different -flive-patching level. */
1230 if (opts
->x_flag_live_patching
)
1232 control_options_for_live_patching (opts
, opts_set
,
1233 opts
->x_flag_live_patching
,
1238 #define LEFT_COLUMN 27
1240 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1241 followed by word-wrapped HELP in a second column. */
1243 wrap_help (const char *help
,
1245 unsigned int item_width
,
1246 unsigned int columns
)
1248 unsigned int col_width
= LEFT_COLUMN
;
1249 unsigned int remaining
, room
, len
;
1251 remaining
= strlen (help
);
1255 room
= columns
- 3 - MAX (col_width
, item_width
);
1264 for (i
= 0; help
[i
]; i
++)
1266 if (i
>= room
&& len
!= remaining
)
1270 else if ((help
[i
] == '-' || help
[i
] == '/')
1271 && help
[i
+ 1] != ' '
1272 && i
> 0 && ISALPHA (help
[i
- 1]))
1277 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1279 while (help
[len
] == ' ')
1287 /* Data structure used to print list of valid option values. */
1289 class option_help_tuple
1292 option_help_tuple (int code
, vec
<const char *> values
):
1293 m_code (code
), m_values (values
)
1296 /* Code of an option. */
1299 /* List of possible values. */
1300 vec
<const char *> m_values
;
1303 /* Print help for a specific front-end, etc. */
1305 print_filtered_help (unsigned int include_flags
,
1306 unsigned int exclude_flags
,
1307 unsigned int any_flags
,
1308 unsigned int columns
,
1309 struct gcc_options
*opts
,
1310 unsigned int lang_mask
)
1315 bool displayed
= false;
1318 if (include_flags
== CL_PARAMS
)
1320 for (i
= 0; i
< LAST_PARAM
; i
++)
1322 const char *param
= compiler_params
[i
].option
;
1324 help
= compiler_params
[i
].help
;
1325 if (help
== NULL
|| *help
== '\0')
1327 if (exclude_flags
& CL_UNDOCUMENTED
)
1329 help
= undocumented_msg
;
1332 /* Get the translation. */
1335 if (!opts
->x_quiet_flag
)
1337 snprintf (new_help
, sizeof (new_help
),
1338 _("default %d minimum %d maximum %d"),
1339 compiler_params
[i
].default_value
,
1340 compiler_params
[i
].min_value
,
1341 compiler_params
[i
].max_value
);
1344 wrap_help (help
, param
, strlen (param
), columns
);
1350 if (!opts
->x_help_printed
)
1351 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1353 if (!opts
->x_help_enum_printed
)
1354 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1356 auto_vec
<option_help_tuple
> help_tuples
;
1358 for (i
= 0; i
< cl_options_count
; i
++)
1360 const struct cl_option
*option
= cl_options
+ i
;
1365 if (include_flags
== 0
1366 || ((option
->flags
& include_flags
) != include_flags
))
1368 if ((option
->flags
& any_flags
) == 0)
1372 /* Skip unwanted switches. */
1373 if ((option
->flags
& exclude_flags
) != 0)
1376 /* The driver currently prints its own help text. */
1377 if ((option
->flags
& CL_DRIVER
) != 0
1378 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1379 | CL_COMMON
| CL_TARGET
)) == 0)
1383 /* Skip switches that have already been printed. */
1384 if (opts
->x_help_printed
[i
])
1387 opts
->x_help_printed
[i
] = true;
1389 help
= option
->help
;
1392 if (exclude_flags
& CL_UNDOCUMENTED
)
1395 help
= undocumented_msg
;
1398 if (option
->alias_target
< N_OPTS
1399 && cl_options
[option
->alias_target
].help
)
1401 if (help
== undocumented_msg
)
1403 /* For undocumented options that are aliases for other options
1404 that are documented, point the reader to the other option in
1405 preference of the former. */
1406 snprintf (new_help
, sizeof new_help
,
1407 _("Same as %s. Use the latter option instead."),
1408 cl_options
[option
->alias_target
].opt_text
);
1412 /* For documented options with aliases, mention the aliased
1413 option's name for reference. */
1414 snprintf (new_help
, sizeof new_help
,
1415 _("%s Same as %s."),
1416 help
, cl_options
[option
->alias_target
].opt_text
);
1422 if (option
->warn_message
)
1424 /* Mention that the use of the option will trigger a warning. */
1425 if (help
== new_help
)
1426 snprintf (new_help
+ strlen (new_help
),
1427 sizeof new_help
- strlen (new_help
),
1428 " %s", _(use_diagnosed_msg
));
1430 snprintf (new_help
, sizeof new_help
,
1431 "%s %s", help
, _(use_diagnosed_msg
));
1436 /* Get the translation. */
1439 /* Find the gap between the name of the
1440 option and its descriptive text. */
1441 tab
= strchr (help
, '\t');
1450 opt
= option
->opt_text
;
1454 /* With the -Q option enabled we change the descriptive text associated
1455 with an option to be an indication of its current setting. */
1456 if (!opts
->x_quiet_flag
)
1458 void *flag_var
= option_flag_var (i
, opts
);
1460 if (len
< (LEFT_COLUMN
+ 2))
1461 strcpy (new_help
, "\t\t");
1463 strcpy (new_help
, "\t");
1465 /* Set to print whether the option is enabled or disabled,
1466 or, if it's an alias for another option, the name of
1467 the aliased option. */
1468 bool print_state
= false;
1470 if (flag_var
!= NULL
1471 && option
->var_type
!= CLVC_DEFER
)
1473 /* If OPTION is only available for a specific subset
1474 of languages other than this one, mention them. */
1475 bool avail_for_lang
= true;
1476 if (unsigned langset
= option
->flags
& CL_LANG_ALL
)
1478 if (!(langset
& lang_mask
))
1480 avail_for_lang
= false;
1481 strcat (new_help
, _("[available in "));
1482 for (unsigned i
= 0, n
= 0; (1U << i
) < CL_LANG_ALL
; ++i
)
1483 if (langset
& (1U << i
))
1486 strcat (new_help
, ", ");
1487 strcat (new_help
, lang_names
[i
]);
1489 strcat (new_help
, "]");
1492 if (!avail_for_lang
)
1493 ; /* Print nothing else if the option is not available
1494 in the current language. */
1495 else if (option
->flags
& CL_JOINED
)
1497 if (option
->var_type
== CLVC_STRING
)
1499 if (* (const char **) flag_var
!= NULL
)
1500 snprintf (new_help
+ strlen (new_help
),
1501 sizeof (new_help
) - strlen (new_help
),
1502 "%s", * (const char **) flag_var
);
1504 else if (option
->var_type
== CLVC_ENUM
)
1506 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1508 const char *arg
= NULL
;
1510 value
= e
->get (flag_var
);
1511 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1513 arg
= _("[default]");
1514 snprintf (new_help
+ strlen (new_help
),
1515 sizeof (new_help
) - strlen (new_help
),
1520 if (option
->cl_host_wide_int
)
1521 sprintf (new_help
+ strlen (new_help
),
1522 _("%llu bytes"), (unsigned long long)
1523 *(unsigned HOST_WIDE_INT
*) flag_var
);
1525 sprintf (new_help
+ strlen (new_help
),
1526 "%i", * (int *) flag_var
);
1533 /* When there is no argument, print the option state only
1534 if the option takes no argument. */
1535 print_state
= !(option
->flags
& CL_JOINED
);
1539 if (option
->alias_target
< N_OPTS
1540 && option
->alias_target
!= OPT_SPECIAL_deprecated
1541 && option
->alias_target
!= OPT_SPECIAL_ignore
1542 && option
->alias_target
!= OPT_SPECIAL_input_file
1543 && option
->alias_target
!= OPT_SPECIAL_program_name
1544 && option
->alias_target
!= OPT_SPECIAL_unknown
)
1546 const struct cl_option
*target
1547 = &cl_options
[option
->alias_target
];
1548 sprintf (new_help
+ strlen (new_help
), "%s%s",
1550 option
->alias_arg
? option
->alias_arg
: "");
1552 else if (option
->alias_target
== OPT_SPECIAL_ignore
)
1553 strcat (new_help
, ("[ignored]"));
1556 /* Print the state for an on/off option. */
1557 int ena
= option_enabled (i
, lang_mask
, opts
);
1559 strcat (new_help
, _("[enabled]"));
1561 strcat (new_help
, _("[disabled]"));
1568 if (option
->range_max
!= -1)
1571 snprintf (b
, sizeof (b
), "<%d,%d>", option
->range_min
,
1573 opt
= concat (opt
, b
, NULL
);
1577 wrap_help (help
, opt
, len
, columns
);
1580 if (option
->var_type
== CLVC_ENUM
1581 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1582 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1585 vec
<const char *> option_values
1586 = targetm_common
.get_valid_option_values (i
, NULL
);
1587 if (!option_values
.is_empty ())
1588 help_tuples
.safe_push (option_help_tuple (i
, option_values
));
1594 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1597 printf (_(" No options with the desired characteristics were found\n"));
1602 /* PR 31349: Tell the user how to see all of the
1603 options supported by a specific front end. */
1604 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1605 if ((1U << i
) & langs
)
1606 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1607 lang_names
[i
], lang_names
[i
]);
1611 else if (! displayed
)
1612 printf (_(" All options with the desired characteristics have already been displayed\n"));
1616 /* Print details of enumerated option arguments, if those
1617 enumerations have help text headings provided. If no help text
1618 is provided, presume that the possible values are listed in the
1619 help text for the relevant options. */
1620 for (i
= 0; i
< cl_enums_count
; i
++)
1622 unsigned int j
, pos
;
1624 if (opts
->x_help_enum_printed
[i
] != 1)
1626 if (cl_enums
[i
].help
== NULL
)
1628 printf (" %s\n ", _(cl_enums
[i
].help
));
1630 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1632 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1634 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1636 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1646 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1651 opts
->x_help_enum_printed
[i
] = 2;
1654 for (unsigned i
= 0; i
< help_tuples
.length (); i
++)
1656 const struct cl_option
*option
= cl_options
+ help_tuples
[i
].m_code
;
1657 printf (_(" Known valid arguments for %s option:\n "),
1659 for (unsigned j
= 0; j
< help_tuples
[i
].m_values
.length (); j
++)
1660 printf (" %s", help_tuples
[i
].m_values
[j
]);
1665 /* Display help for a specified type of option.
1666 The options must have ALL of the INCLUDE_FLAGS set
1667 ANY of the flags in the ANY_FLAGS set
1668 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1669 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1671 print_specific_help (unsigned int include_flags
,
1672 unsigned int exclude_flags
,
1673 unsigned int any_flags
,
1674 struct gcc_options
*opts
,
1675 unsigned int lang_mask
)
1677 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1678 const char * description
= NULL
;
1679 const char * descrip_extra
= "";
1683 /* Sanity check: Make sure that we do not have more
1684 languages than we have bits available to enumerate them. */
1685 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1687 /* If we have not done so already, obtain
1688 the desired maximum width of the output. */
1689 if (opts
->x_help_columns
== 0)
1691 opts
->x_help_columns
= get_terminal_width ();
1692 if (opts
->x_help_columns
== INT_MAX
)
1693 /* Use a reasonable default. */
1694 opts
->x_help_columns
= 80;
1697 /* Decide upon the title for the options that we are going to display. */
1698 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1700 switch (flag
& include_flags
)
1707 description
= _("The following options are target specific");
1710 description
= _("The following options control compiler warning messages");
1712 case CL_OPTIMIZATION
:
1713 description
= _("The following options control optimizations");
1716 description
= _("The following options are language-independent");
1719 description
= _("The --param option recognizes the following as parameters");
1722 if (i
>= cl_lang_count
)
1724 if (exclude_flags
& all_langs_mask
)
1725 description
= _("The following options are specific to just the language ");
1727 description
= _("The following options are supported by the language ");
1728 descrip_extra
= lang_names
[i
];
1733 if (description
== NULL
)
1737 if (include_flags
& CL_UNDOCUMENTED
)
1738 description
= _("The following options are not documented");
1739 else if (include_flags
& CL_SEPARATE
)
1740 description
= _("The following options take separate arguments");
1741 else if (include_flags
& CL_JOINED
)
1742 description
= _("The following options take joined arguments");
1745 internal_error ("unrecognized %<include_flags 0x%x%> passed "
1746 "to %<print_specific_help%>",
1753 if (any_flags
& all_langs_mask
)
1754 description
= _("The following options are language-related");
1756 description
= _("The following options are language-independent");
1760 printf ("%s%s:\n", description
, descrip_extra
);
1761 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
1762 opts
->x_help_columns
, opts
, lang_mask
);
1765 /* Enable FDO-related flags. */
1768 enable_fdo_optimizations (struct gcc_options
*opts
,
1769 struct gcc_options
*opts_set
,
1772 if (!opts_set
->x_flag_branch_probabilities
)
1773 opts
->x_flag_branch_probabilities
= value
;
1774 if (!opts_set
->x_flag_profile_values
)
1775 opts
->x_flag_profile_values
= value
;
1776 if (!opts_set
->x_flag_unroll_loops
)
1777 opts
->x_flag_unroll_loops
= value
;
1778 if (!opts_set
->x_flag_peel_loops
)
1779 opts
->x_flag_peel_loops
= value
;
1780 if (!opts_set
->x_flag_tracer
)
1781 opts
->x_flag_tracer
= value
;
1782 if (!opts_set
->x_flag_value_profile_transformations
)
1783 opts
->x_flag_value_profile_transformations
= value
;
1784 if (!opts_set
->x_flag_inline_functions
)
1785 opts
->x_flag_inline_functions
= value
;
1786 if (!opts_set
->x_flag_ipa_cp
)
1787 opts
->x_flag_ipa_cp
= value
;
1788 if (!opts_set
->x_flag_ipa_cp_clone
1789 && value
&& opts
->x_flag_ipa_cp
)
1790 opts
->x_flag_ipa_cp_clone
= value
;
1791 if (!opts_set
->x_flag_ipa_bit_cp
1792 && value
&& opts
->x_flag_ipa_cp
)
1793 opts
->x_flag_ipa_bit_cp
= value
;
1794 if (!opts_set
->x_flag_predictive_commoning
)
1795 opts
->x_flag_predictive_commoning
= value
;
1796 if (!opts_set
->x_flag_split_loops
)
1797 opts
->x_flag_split_loops
= value
;
1798 if (!opts_set
->x_flag_unswitch_loops
)
1799 opts
->x_flag_unswitch_loops
= value
;
1800 if (!opts_set
->x_flag_gcse_after_reload
)
1801 opts
->x_flag_gcse_after_reload
= value
;
1802 if (!opts_set
->x_flag_tree_loop_vectorize
)
1803 opts
->x_flag_tree_loop_vectorize
= value
;
1804 if (!opts_set
->x_flag_tree_slp_vectorize
)
1805 opts
->x_flag_tree_slp_vectorize
= value
;
1806 if (!opts_set
->x_flag_version_loops_for_strides
)
1807 opts
->x_flag_version_loops_for_strides
= value
;
1808 if (!opts_set
->x_flag_vect_cost_model
)
1809 opts
->x_flag_vect_cost_model
= VECT_COST_MODEL_DYNAMIC
;
1810 if (!opts_set
->x_flag_tree_loop_distribute_patterns
)
1811 opts
->x_flag_tree_loop_distribute_patterns
= value
;
1812 if (!opts_set
->x_flag_loop_interchange
)
1813 opts
->x_flag_loop_interchange
= value
;
1814 if (!opts_set
->x_flag_unroll_jam
)
1815 opts
->x_flag_unroll_jam
= value
;
1816 if (!opts_set
->x_flag_tree_loop_distribution
)
1817 opts
->x_flag_tree_loop_distribution
= value
;
1820 /* -f{,no-}sanitize{,-recover}= suboptions. */
1821 const struct sanitizer_opts_s sanitizer_opts
[] =
1823 #define SANITIZER_OPT(name, flags, recover) \
1824 { #name, flags, sizeof #name - 1, recover }
1825 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true),
1826 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
1828 SANITIZER_OPT (pointer
-compare
, SANITIZE_POINTER_COMPARE
, true),
1829 SANITIZER_OPT (pointer
-subtract
, SANITIZE_POINTER_SUBTRACT
, true),
1830 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false),
1831 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false),
1832 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true),
1833 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true),
1834 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true),
1835 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true),
1836 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true),
1837 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false),
1838 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true),
1839 SANITIZER_OPT (return, SANITIZE_RETURN
, false),
1840 SANITIZER_OPT (null
, SANITIZE_NULL
, true),
1841 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true),
1842 SANITIZER_OPT (bool, SANITIZE_BOOL
, true),
1843 SANITIZER_OPT (enum, SANITIZE_ENUM
, true),
1844 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true),
1845 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true),
1846 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true),
1847 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true),
1848 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true),
1849 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true),
1850 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
1852 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true),
1853 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true),
1854 SANITIZER_OPT (pointer
-overflow
, SANITIZE_POINTER_OVERFLOW
, true),
1855 SANITIZER_OPT (builtin
, SANITIZE_BUILTIN
, true),
1856 SANITIZER_OPT (all
, ~0U, true),
1857 #undef SANITIZER_OPT
1858 { NULL
, 0U, 0UL, false }
1861 /* -f{,no-}sanitize-coverage= suboptions. */
1862 const struct sanitizer_opts_s coverage_sanitizer_opts
[] =
1864 #define COVERAGE_SANITIZER_OPT(name, flags) \
1865 { #name, flags, sizeof #name - 1, true }
1866 COVERAGE_SANITIZER_OPT (trace
-pc
, SANITIZE_COV_TRACE_PC
),
1867 COVERAGE_SANITIZER_OPT (trace
-cmp
, SANITIZE_COV_TRACE_CMP
),
1868 #undef COVERAGE_SANITIZER_OPT
1869 { NULL
, 0U, 0UL, false }
1872 /* A struct for describing a run of chars within a string. */
1874 class string_fragment
1877 string_fragment (const char *start
, size_t len
)
1878 : m_start (start
), m_len (len
) {}
1880 const char *m_start
;
1884 /* Specialization of edit_distance_traits for string_fragment,
1885 for use by get_closest_sanitizer_option. */
1888 struct edit_distance_traits
<const string_fragment
&>
1890 static size_t get_length (const string_fragment
&fragment
)
1892 return fragment
.m_len
;
1895 static const char *get_string (const string_fragment
&fragment
)
1897 return fragment
.m_start
;
1901 /* Given ARG, an unrecognized sanitizer option, return the best
1902 matching sanitizer option, or NULL if there isn't one.
1903 OPTS is array of candidate sanitizer options.
1904 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or
1905 OPT_fsanitize_coverage_.
1906 VALUE is non-zero for the regular form of the option, zero
1907 for the "no-" form (e.g. "-fno-sanitize-recover="). */
1910 get_closest_sanitizer_option (const string_fragment
&arg
,
1911 const struct sanitizer_opts_s
*opts
,
1912 enum opt_code code
, int value
)
1914 best_match
<const string_fragment
&, const char*> bm (arg
);
1915 for (int i
= 0; opts
[i
].name
!= NULL
; ++i
)
1917 /* -fsanitize=all is not valid, so don't offer it. */
1918 if (code
== OPT_fsanitize_
1919 && opts
[i
].flag
== ~0U
1923 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
1924 don't offer the non-recoverable options. */
1925 if (code
== OPT_fsanitize_recover_
1926 && !opts
[i
].can_recover
1930 bm
.consider (opts
[i
].name
);
1932 return bm
.get_best_meaningful_candidate ();
1935 /* Parse comma separated sanitizer suboptions from P for option SCODE,
1936 adjust previous FLAGS and return new ones. If COMPLAIN is false,
1937 don't issue diagnostics. */
1940 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
1941 unsigned int flags
, int value
, bool complain
)
1943 enum opt_code code
= (enum opt_code
) scode
;
1945 const struct sanitizer_opts_s
*opts
;
1946 if (code
== OPT_fsanitize_coverage_
)
1947 opts
= coverage_sanitizer_opts
;
1949 opts
= sanitizer_opts
;
1955 const char *comma
= strchr (p
, ',');
1967 /* Check to see if the string matches an option class name. */
1968 for (i
= 0; opts
[i
].name
!= NULL
; ++i
)
1969 if (len
== opts
[i
].len
&& memcmp (p
, opts
[i
].name
, len
) == 0)
1971 /* Handle both -fsanitize and -fno-sanitize cases. */
1972 if (value
&& opts
[i
].flag
== ~0U)
1974 if (code
== OPT_fsanitize_
)
1977 error_at (loc
, "%<-fsanitize=all%> option is not valid");
1980 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
1981 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
1985 /* Do not enable -fsanitize-recover=unreachable and
1986 -fsanitize-recover=return if -fsanitize-recover=undefined
1988 if (code
== OPT_fsanitize_recover_
1989 && opts
[i
].flag
== SANITIZE_UNDEFINED
)
1990 flags
|= (SANITIZE_UNDEFINED
1991 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
1993 flags
|= opts
[i
].flag
;
1996 flags
&= ~opts
[i
].flag
;
2001 if (! found
&& complain
)
2004 = get_closest_sanitizer_option (string_fragment (p
, len
),
2008 if (code
== OPT_fsanitize_recover_
)
2009 suffix
= "-recover";
2010 else if (code
== OPT_fsanitize_coverage_
)
2011 suffix
= "-coverage";
2017 "unrecognized argument to %<-f%ssanitize%s=%> "
2018 "option: %q.*s; did you mean %qs?",
2020 suffix
, (int) len
, p
, hint
);
2023 "unrecognized argument to %<-f%ssanitize%s=%> option: "
2024 "%q.*s", value
? "" : "no-",
2025 suffix
, (int) len
, p
);
2035 /* Parse string values of no_sanitize attribute passed in VALUE.
2036 Values are separated with comma. */
2039 parse_no_sanitize_attribute (char *value
)
2041 unsigned int flags
= 0;
2043 char *q
= strtok (value
, ",");
2047 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
2048 if (strcmp (sanitizer_opts
[i
].name
, q
) == 0)
2050 flags
|= sanitizer_opts
[i
].flag
;
2051 if (sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
2052 flags
|= SANITIZE_UNDEFINED_NONDEFAULT
;
2056 if (sanitizer_opts
[i
].name
== NULL
)
2057 warning (OPT_Wattributes
,
2058 "%qs attribute directive ignored", q
);
2060 q
= strtok (NULL
, ",");
2066 /* Parse -falign-NAME format for a FLAG value. Return individual
2067 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
2068 set, print error message at LOC location. */
2071 parse_and_check_align_values (const char *flag
,
2073 auto_vec
<unsigned> &result_values
,
2077 char *str
= xstrdup (flag
);
2078 for (char *p
= strtok (str
, ":"); p
; p
= strtok (NULL
, ":"))
2081 int v
= strtol (p
, &end
, 10);
2082 if (*end
!= '\0' || v
< 0)
2085 error_at (loc
, "invalid arguments for %<-falign-%s%> option: %qs",
2091 result_values
.safe_push ((unsigned)v
);
2096 /* Check that we have a correct number of values. */
2097 if (result_values
.is_empty () || result_values
.length () > 4)
2100 error_at (loc
, "invalid number of arguments for %<-falign-%s%> "
2101 "option: %qs", name
, flag
);
2105 for (unsigned i
= 0; i
< result_values
.length (); i
++)
2106 if (result_values
[i
] > MAX_CODE_ALIGN_VALUE
)
2109 error_at (loc
, "%<-falign-%s%> is not between 0 and %d",
2110 name
, MAX_CODE_ALIGN_VALUE
);
2117 /* Check that alignment value FLAG for -falign-NAME is valid at a given
2121 check_alignment_argument (location_t loc
, const char *flag
, const char *name
)
2123 auto_vec
<unsigned> align_result
;
2124 parse_and_check_align_values (flag
, name
, align_result
, true, loc
);
2127 /* Print help when OPT__help_ is set. */
2130 print_help (struct gcc_options
*opts
, unsigned int lang_mask
,
2131 const char *help_option_argument
)
2133 const char *a
= help_option_argument
;
2134 unsigned int include_flags
= 0;
2135 /* Note - by default we include undocumented options when listing
2136 specific classes. If you only want to see documented options
2137 then add ",^undocumented" to the --help= option. E.g.:
2139 --help=target,^undocumented */
2140 unsigned int exclude_flags
= 0;
2142 if (lang_mask
== CL_DRIVER
)
2145 /* Walk along the argument string, parsing each word in turn.
2147 arg = [^]{word}[,{arg}]
2148 word = {optimizers|target|warnings|undocumented|
2149 params|common|<language>} */
2159 { "optimizers", CL_OPTIMIZATION
},
2160 { "target", CL_TARGET
},
2161 { "warnings", CL_WARNING
},
2162 { "undocumented", CL_UNDOCUMENTED
},
2163 { "params", CL_PARAMS
},
2164 { "joined", CL_JOINED
},
2165 { "separate", CL_SEPARATE
},
2166 { "common", CL_COMMON
},
2169 unsigned int *pflags
;
2171 unsigned int lang_flag
, specific_flag
;
2180 error ("missing argument to %qs", "--help=^");
2183 pflags
= &exclude_flags
;
2186 pflags
= &include_flags
;
2188 comma
= strchr (a
, ',');
2199 /* Check to see if the string matches an option class name. */
2200 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
2201 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
2203 specific_flag
= specifics
[i
].flag
;
2207 /* Check to see if the string matches a language name.
2208 Note - we rely upon the alpha-sorted nature of the entries in
2209 the lang_names array, specifically that shorter names appear
2210 before their longer variants. (i.e. C before C++). That way
2211 when we are attempting to match --help=c for example we will
2212 match with C first and not C++. */
2213 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
2214 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
2216 lang_flag
= 1U << i
;
2220 if (specific_flag
!= 0)
2223 *pflags
|= specific_flag
;
2226 /* The option's argument matches both the start of a
2227 language name and the start of an option class name.
2228 We have a special case for when the user has
2229 specified "--help=c", but otherwise we have to issue
2231 if (strncasecmp (a
, "c", len
) == 0)
2232 *pflags
|= lang_flag
;
2235 "%<--help%> argument %q.*s is ambiguous, "
2236 "please be more specific",
2240 else if (lang_flag
!= 0)
2241 *pflags
|= lang_flag
;
2244 "unrecognized argument to %<--help=%> option: %q.*s",
2253 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
2257 /* Handle target- and language-independent options. Return zero to
2258 generate an "unknown option" message. Only options that need
2259 extra handling need to be listed here; if you simply want
2260 DECODED->value assigned to a variable, it happens automatically. */
2263 common_handle_option (struct gcc_options
*opts
,
2264 struct gcc_options
*opts_set
,
2265 const struct cl_decoded_option
*decoded
,
2266 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
2268 const struct cl_option_handlers
*handlers
,
2269 diagnostic_context
*dc
,
2270 void (*target_option_override_hook
) (void))
2272 size_t scode
= decoded
->opt_index
;
2273 const char *arg
= decoded
->arg
;
2274 HOST_WIDE_INT value
= decoded
->value
;
2275 enum opt_code code
= (enum opt_code
) scode
;
2277 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
2282 handle_param (opts
, opts_set
, loc
, arg
);
2287 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
2288 unsigned int undoc_mask
;
2291 if (lang_mask
== CL_DRIVER
)
2294 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
2297 target_option_override_hook ();
2298 /* First display any single language specific options. */
2299 for (i
= 0; i
< cl_lang_count
; i
++)
2301 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
2303 /* Next display any multi language specific options. */
2304 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
2305 /* Then display any remaining, non-language options. */
2306 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
2308 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
2309 opts
->x_exit_after_options
= true;
2313 case OPT__target_help
:
2314 if (lang_mask
== CL_DRIVER
)
2317 target_option_override_hook ();
2318 print_specific_help (CL_TARGET
, CL_UNDOCUMENTED
, 0, opts
, lang_mask
);
2319 opts
->x_exit_after_options
= true;
2324 help_option_arguments
.safe_push (arg
);
2325 opts
->x_exit_after_options
= true;
2330 if (lang_mask
== CL_DRIVER
)
2333 opts
->x_exit_after_options
= true;
2336 case OPT__completion_
:
2339 case OPT_fsanitize_
:
2340 opts
->x_flag_sanitize
2341 = parse_sanitizer_options (arg
, loc
, code
,
2342 opts
->x_flag_sanitize
, value
, true);
2344 /* Kernel ASan implies normal ASan but does not yet support
2346 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
2348 maybe_set_param_value (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD
,
2349 0, opts
->x_param_values
,
2350 opts_set
->x_param_values
);
2351 maybe_set_param_value (PARAM_ASAN_GLOBALS
, 0, opts
->x_param_values
,
2352 opts_set
->x_param_values
);
2353 maybe_set_param_value (PARAM_ASAN_STACK
, 0, opts
->x_param_values
,
2354 opts_set
->x_param_values
);
2355 maybe_set_param_value (PARAM_ASAN_PROTECT_ALLOCAS
, 0,
2356 opts
->x_param_values
,
2357 opts_set
->x_param_values
);
2358 maybe_set_param_value (PARAM_ASAN_USE_AFTER_RETURN
, 0,
2359 opts
->x_param_values
,
2360 opts_set
->x_param_values
);
2364 case OPT_fsanitize_recover_
:
2365 opts
->x_flag_sanitize_recover
2366 = parse_sanitizer_options (arg
, loc
, code
,
2367 opts
->x_flag_sanitize_recover
, value
, true);
2370 case OPT_fasan_shadow_offset_
:
2374 case OPT_fsanitize_address_use_after_scope
:
2375 opts
->x_flag_sanitize_address_use_after_scope
= value
;
2378 case OPT_fsanitize_recover
:
2380 opts
->x_flag_sanitize_recover
2381 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)
2382 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2384 opts
->x_flag_sanitize_recover
2385 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2388 case OPT_fsanitize_coverage_
:
2389 opts
->x_flag_sanitize_coverage
2390 = parse_sanitizer_options (arg
, loc
, code
,
2391 opts
->x_flag_sanitize_coverage
, value
, true);
2398 /* Currently handled in a prescan. */
2402 dc
->warning_as_error_requested
= value
;
2406 if (lang_mask
== CL_DRIVER
)
2409 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
2410 opts
, opts_set
, loc
, dc
);
2413 case OPT_Wfatal_errors
:
2414 dc
->fatal_errors
= value
;
2417 case OPT_Wstack_usage_
:
2418 opts
->x_flag_stack_usage_info
= value
!= -1;
2421 case OPT_Wstrict_aliasing
:
2422 set_Wstrict_aliasing (opts
, value
);
2425 case OPT_Wstrict_overflow
:
2426 opts
->x_warn_strict_overflow
= (value
2427 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2431 case OPT_Wsystem_headers
:
2432 dc
->dc_warn_system_headers
= value
;
2436 opts
->x_flag_gen_aux_info
= 1;
2439 case OPT_auxbase_strip
:
2441 char *tmp
= xstrdup (arg
);
2442 strip_off_ending (tmp
, strlen (tmp
));
2444 opts
->x_aux_base_name
= tmp
;
2451 decode_d_option (arg
, opts
, loc
, dc
);
2454 case OPT_fcall_used_
:
2455 case OPT_fcall_saved_
:
2463 case OPT_fdbg_cnt_list
:
2465 opts
->x_exit_after_options
= true;
2468 case OPT_fdebug_prefix_map_
:
2469 case OPT_ffile_prefix_map_
:
2473 case OPT_fdiagnostics_show_location_
:
2474 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2477 case OPT_fdiagnostics_show_caret
:
2478 dc
->show_caret
= value
;
2481 case OPT_fdiagnostics_show_labels
:
2482 dc
->show_labels_p
= value
;
2485 case OPT_fdiagnostics_show_line_numbers
:
2486 dc
->show_line_numbers_p
= value
;
2489 case OPT_fdiagnostics_color_
:
2490 diagnostic_color_init (dc
, value
);
2493 case OPT_fdiagnostics_format_
:
2494 diagnostic_output_format_init (dc
,
2495 (enum diagnostics_output_format
)value
);
2498 case OPT_fdiagnostics_parseable_fixits
:
2499 dc
->parseable_fixits_p
= value
;
2502 case OPT_fdiagnostics_show_option
:
2503 dc
->show_option_requested
= value
;
2506 case OPT_fdiagnostics_minimum_margin_width_
:
2507 dc
->min_margin_width
= value
;
2514 case OPT_ffast_math
:
2515 set_fast_math_flags (opts
, value
);
2518 case OPT_funsafe_math_optimizations
:
2519 set_unsafe_math_optimizations_flags (opts
, value
);
2526 case OPT_finline_limit_
:
2527 set_param_value ("max-inline-insns-single", value
/ 2,
2528 opts
->x_param_values
, opts_set
->x_param_values
);
2529 set_param_value ("max-inline-insns-auto", value
/ 2,
2530 opts
->x_param_values
, opts_set
->x_param_values
);
2533 case OPT_finstrument_functions_exclude_function_list_
:
2534 add_comma_separated_to_vector
2535 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2538 case OPT_finstrument_functions_exclude_file_list_
:
2539 add_comma_separated_to_vector
2540 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2543 case OPT_fmessage_length_
:
2544 pp_set_line_maximum_length (dc
->printer
, value
);
2545 diagnostic_set_caret_max_width (dc
, value
);
2549 case OPT_fopt_info_
:
2555 const char *p
= arg
;
2556 opts
->x_flag_disable_hsa
= true;
2559 const char *comma
= strchr (p
, ',');
2561 if ((strncmp (p
, "disable", 7) == 0)
2562 && (p
[7] == ',' || p
[7] == '\0'))
2564 opts
->x_flag_disable_hsa
= true;
2568 if ((strncmp (p
, "hsa", 3) == 0)
2569 && (p
[3] == ',' || p
[3] == '\0'))
2572 opts
->x_flag_disable_hsa
= false;
2574 sorry ("HSA has not been enabled during configuration");
2584 #ifndef ACCEL_COMPILER
2585 case OPT_foffload_abi_
:
2586 error_at (loc
, "%<-foffload-abi%> option can be specified only for "
2587 "offload compiler");
2591 case OPT_fpack_struct_
:
2592 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2594 "structure alignment must be a small power of two, not %wu",
2597 opts
->x_initial_max_fld_align
= value
;
2601 case OPT_fplugin_arg_
:
2605 case OPT_fprofile_use_
:
2606 opts
->x_profile_data_prefix
= xstrdup (arg
);
2607 opts
->x_flag_profile_use
= true;
2609 /* No break here - do -fprofile-use processing. */
2611 case OPT_fprofile_use
:
2612 enable_fdo_optimizations (opts
, opts_set
, value
);
2613 if (!opts_set
->x_flag_profile_reorder_functions
)
2614 opts
->x_flag_profile_reorder_functions
= value
;
2615 /* Indirect call profiling should do all useful transformations
2616 speculative devirtualization does. */
2617 if (!opts_set
->x_flag_devirtualize_speculatively
2618 && opts
->x_flag_value_profile_transformations
)
2619 opts
->x_flag_devirtualize_speculatively
= false;
2622 case OPT_fauto_profile_
:
2623 opts
->x_auto_profile_file
= xstrdup (arg
);
2624 opts
->x_flag_auto_profile
= true;
2626 /* No break here - do -fauto-profile processing. */
2628 case OPT_fauto_profile
:
2629 enable_fdo_optimizations (opts
, opts_set
, value
);
2630 if (!opts_set
->x_flag_profile_correction
)
2631 opts
->x_flag_profile_correction
= value
;
2632 maybe_set_param_value (
2633 PARAM_EARLY_INLINER_MAX_ITERATIONS
, 10,
2634 opts
->x_param_values
, opts_set
->x_param_values
);
2637 case OPT_fprofile_generate_
:
2638 opts
->x_profile_data_prefix
= xstrdup (arg
);
2640 /* No break here - do -fprofile-generate processing. */
2642 case OPT_fprofile_generate
:
2643 if (!opts_set
->x_profile_arc_flag
)
2644 opts
->x_profile_arc_flag
= value
;
2645 if (!opts_set
->x_flag_profile_values
)
2646 opts
->x_flag_profile_values
= value
;
2647 if (!opts_set
->x_flag_inline_functions
)
2648 opts
->x_flag_inline_functions
= value
;
2649 if (!opts_set
->x_flag_ipa_bit_cp
)
2650 opts
->x_flag_ipa_bit_cp
= value
;
2651 /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
2652 quadratic. Disable the pass until better memory representation
2654 if (!opts_set
->x_flag_ipa_reference
)
2655 opts
->x_flag_ipa_reference
= false;
2658 case OPT_fpatchable_function_entry_
:
2660 char *patch_area_arg
= xstrdup (arg
);
2661 char *comma
= strchr (patch_area_arg
, ',');
2665 function_entry_patch_area_size
=
2666 integral_argument (patch_area_arg
);
2667 function_entry_patch_area_start
=
2668 integral_argument (comma
+ 1);
2672 function_entry_patch_area_size
=
2673 integral_argument (patch_area_arg
);
2674 function_entry_patch_area_start
= 0;
2676 if (function_entry_patch_area_size
< 0
2677 || function_entry_patch_area_start
< 0
2678 || function_entry_patch_area_size
2679 < function_entry_patch_area_start
)
2680 error ("invalid arguments for %<-fpatchable_function_entry%>");
2681 free (patch_area_arg
);
2685 case OPT_ftree_vectorize
:
2686 /* Automatically sets -ftree-loop-vectorize and
2687 -ftree-slp-vectorize. Nothing more to do here. */
2689 case OPT_fshow_column
:
2690 dc
->show_column
= value
;
2693 case OPT_frandom_seed
:
2694 /* The real switch is -fno-random-seed. */
2700 case OPT_frandom_seed_
:
2704 case OPT_fsched_verbose_
:
2705 #ifdef INSN_SCHEDULING
2706 /* Handled with Var in common.opt. */
2712 case OPT_fsched_stalled_insns_
:
2713 opts
->x_flag_sched_stalled_insns
= value
;
2714 if (opts
->x_flag_sched_stalled_insns
== 0)
2715 opts
->x_flag_sched_stalled_insns
= -1;
2718 case OPT_fsched_stalled_insns_dep_
:
2719 opts
->x_flag_sched_stalled_insns_dep
= value
;
2722 case OPT_fstack_check_
:
2723 if (!strcmp (arg
, "no"))
2724 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
2725 else if (!strcmp (arg
, "generic"))
2726 /* This is the old stack checking method. */
2727 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2728 ? FULL_BUILTIN_STACK_CHECK
2729 : GENERIC_STACK_CHECK
;
2730 else if (!strcmp (arg
, "specific"))
2731 /* This is the new stack checking method. */
2732 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2733 ? FULL_BUILTIN_STACK_CHECK
2734 : STACK_CHECK_STATIC_BUILTIN
2735 ? STATIC_BUILTIN_STACK_CHECK
2736 : GENERIC_STACK_CHECK
;
2738 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
2741 case OPT_fstack_limit
:
2742 /* The real switch is -fno-stack-limit. */
2748 case OPT_fstack_limit_register_
:
2749 case OPT_fstack_limit_symbol_
:
2753 case OPT_fstack_usage
:
2754 opts
->x_flag_stack_usage
= value
;
2755 opts
->x_flag_stack_usage_info
= value
!= 0;
2759 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
2764 if (arg
&& strlen (arg
) != 0)
2766 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
2767 "use %<-gdwarf-%s%> for DWARF version "
2768 "or %<-gdwarf%> %<-g%s%> for debug level", arg
, arg
, arg
);
2772 value
= opts
->x_dwarf_version
;
2776 if (value
< 2 || value
> 5)
2777 error_at (loc
, "dwarf version %wu is not supported", value
);
2779 opts
->x_dwarf_version
= value
;
2780 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
2783 case OPT_gsplit_dwarf
:
2784 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, "", opts
, opts_set
,
2789 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
2794 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
, opts
, opts_set
,
2799 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2804 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
, opts
, opts_set
,
2810 /* Handled completely via specs. */
2813 case OPT_pedantic_errors
:
2814 dc
->pedantic_errors
= 1;
2815 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
2817 handlers
, opts
, opts_set
,
2822 opts
->x_flag_lto
= value
? "" : NULL
;
2826 if (strcmp (arg
, "none") != 0
2827 && strcmp (arg
, "jobserver") != 0
2828 && strcmp (arg
, "auto") != 0
2831 "unrecognized argument to %<-flto=%> option: %qs", arg
);
2835 dc
->dc_inhibit_warnings
= true;
2838 case OPT_fmax_errors_
:
2839 dc
->max_errors
= value
;
2842 case OPT_fuse_ld_bfd
:
2843 case OPT_fuse_ld_gold
:
2844 case OPT_fuse_ld_lld
:
2845 case OPT_fuse_linker_plugin
:
2846 /* No-op. Used by the driver and passed to us because it starts with f.*/
2851 opts
->x_flag_trapv
= 0;
2856 opts
->x_flag_wrapv
= 0;
2859 case OPT_fstrict_overflow
:
2860 opts
->x_flag_wrapv
= !value
;
2861 opts
->x_flag_wrapv_pointer
= !value
;
2863 opts
->x_flag_trapv
= 0;
2867 opts
->x_flag_ipa_icf_functions
= value
;
2868 opts
->x_flag_ipa_icf_variables
= value
;
2871 case OPT_falign_loops_
:
2872 check_alignment_argument (loc
, arg
, "loops");
2875 case OPT_falign_jumps_
:
2876 check_alignment_argument (loc
, arg
, "jumps");
2879 case OPT_falign_labels_
:
2880 check_alignment_argument (loc
, arg
, "labels");
2883 case OPT_falign_functions_
:
2884 check_alignment_argument (loc
, arg
, "functions");
2888 /* If the flag was handled in a standard way, assume the lack of
2889 processing here is intentional. */
2890 gcc_assert (option_flag_var (scode
, opts
));
2894 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
2899 /* Handle --param NAME=VALUE. */
2901 handle_param (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2902 location_t loc
, const char *carg
)
2907 arg
= xstrdup (carg
);
2908 equal
= strchr (arg
, '=');
2910 error_at (loc
, "%s: %qs arguments should be of the form NAME=VALUE",
2916 enum compiler_param index
;
2917 if (!find_param (arg
, &index
))
2919 const char *suggestion
= find_param_fuzzy (arg
);
2921 error_at (loc
, "invalid %qs name %qs; did you mean %qs?",
2922 "--param", arg
, suggestion
);
2924 error_at (loc
, "invalid %qs name %qs", "--param", arg
);
2928 if (!param_string_value_p (index
, equal
+ 1, &value
))
2929 value
= integral_argument (equal
+ 1);
2932 error_at (loc
, "invalid %qs value %qs", "--param", equal
+ 1);
2934 set_param_value (arg
, value
,
2935 opts
->x_param_values
, opts_set
->x_param_values
);
2942 /* Used to set the level of strict aliasing warnings in OPTS,
2943 when no level is specified (i.e., when -Wstrict-aliasing, and not
2944 -Wstrict-aliasing=level was given).
2945 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2946 and 0 otherwise. After calling this function, wstrict_aliasing will be
2947 set to the default value of -Wstrict_aliasing=level, currently 3. */
2949 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
2951 gcc_assert (onoff
== 0 || onoff
== 1);
2953 opts
->x_warn_strict_aliasing
= 3;
2955 opts
->x_warn_strict_aliasing
= 0;
2958 /* The following routines are useful in setting all the flags that
2959 -ffast-math and -fno-fast-math imply. */
2961 set_fast_math_flags (struct gcc_options
*opts
, int set
)
2963 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
2965 opts
->x_flag_unsafe_math_optimizations
= set
;
2966 set_unsafe_math_optimizations_flags (opts
, set
);
2968 if (!opts
->frontend_set_flag_finite_math_only
)
2969 opts
->x_flag_finite_math_only
= set
;
2970 if (!opts
->frontend_set_flag_errno_math
)
2971 opts
->x_flag_errno_math
= !set
;
2974 if (opts
->frontend_set_flag_excess_precision
== EXCESS_PRECISION_DEFAULT
)
2975 opts
->x_flag_excess_precision
2976 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
2977 if (!opts
->frontend_set_flag_signaling_nans
)
2978 opts
->x_flag_signaling_nans
= 0;
2979 if (!opts
->frontend_set_flag_rounding_math
)
2980 opts
->x_flag_rounding_math
= 0;
2981 if (!opts
->frontend_set_flag_cx_limited_range
)
2982 opts
->x_flag_cx_limited_range
= 1;
2986 /* When -funsafe-math-optimizations is set the following
2987 flags are set as well. */
2989 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
2991 if (!opts
->frontend_set_flag_trapping_math
)
2992 opts
->x_flag_trapping_math
= !set
;
2993 if (!opts
->frontend_set_flag_signed_zeros
)
2994 opts
->x_flag_signed_zeros
= !set
;
2995 if (!opts
->frontend_set_flag_associative_math
)
2996 opts
->x_flag_associative_math
= set
;
2997 if (!opts
->frontend_set_flag_reciprocal_math
)
2998 opts
->x_flag_reciprocal_math
= set
;
3001 /* Return true iff flags in OPTS are set as if -ffast-math. */
3003 fast_math_flags_set_p (const struct gcc_options
*opts
)
3005 return (!opts
->x_flag_trapping_math
3006 && opts
->x_flag_unsafe_math_optimizations
3007 && opts
->x_flag_finite_math_only
3008 && !opts
->x_flag_signed_zeros
3009 && !opts
->x_flag_errno_math
3010 && opts
->x_flag_excess_precision
== EXCESS_PRECISION_FAST
);
3013 /* Return true iff flags are set as if -ffast-math but using the flags stored
3014 in the struct cl_optimization structure. */
3016 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
3018 return (!opt
->x_flag_trapping_math
3019 && opt
->x_flag_unsafe_math_optimizations
3020 && opt
->x_flag_finite_math_only
3021 && !opt
->x_flag_signed_zeros
3022 && !opt
->x_flag_errno_math
);
3025 /* Handle a debug output -g switch for options OPTS
3026 (OPTS_SET->x_write_symbols storing whether a debug type was passed
3027 explicitly), location LOC. EXTENDED is true or false to support
3028 extended output (2 is special and means "-ggdb" was given). */
3030 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
,
3031 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
3034 opts
->x_use_gnu_debug_info_extensions
= extended
;
3036 if (type
== NO_DEBUG
)
3038 if (opts
->x_write_symbols
== NO_DEBUG
)
3040 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
3044 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
3045 opts
->x_write_symbols
= DWARF2_DEBUG
;
3046 #elif defined DBX_DEBUGGING_INFO
3047 opts
->x_write_symbols
= DBX_DEBUG
;
3051 if (opts
->x_write_symbols
== NO_DEBUG
)
3052 warning_at (loc
, 0, "target system does not support debug output");
3057 /* Does it conflict with an already selected type? */
3058 if (opts_set
->x_write_symbols
!= NO_DEBUG
3059 && opts
->x_write_symbols
!= NO_DEBUG
3060 && type
!= opts
->x_write_symbols
)
3061 error_at (loc
, "debug format %qs conflicts with prior selection",
3062 debug_type_names
[type
]);
3063 opts
->x_write_symbols
= type
;
3064 opts_set
->x_write_symbols
= type
;
3067 /* A debug flag without a level defaults to level 2.
3068 If off or at level 1, set it to level 2, but if already
3069 at level 3, don't lower it. */
3072 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
3073 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
3077 int argval
= integral_argument (arg
);
3079 error_at (loc
, "unrecognized debug output level %qs", arg
);
3080 else if (argval
> 3)
3081 error_at (loc
, "debug output level %qs is too high", arg
);
3083 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
3087 /* Arrange to dump core on error for diagnostic context DC. (The
3088 regular error message is still printed first, except in the case of
3092 setup_core_dumping (diagnostic_context
*dc
)
3095 signal (SIGABRT
, SIG_DFL
);
3097 #if defined(HAVE_SETRLIMIT)
3100 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
3101 fatal_error (input_location
, "getting core file size maximum limit: %m");
3102 rlim
.rlim_cur
= rlim
.rlim_max
;
3103 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
3104 fatal_error (input_location
,
3105 "setting core file size limit to maximum: %m");
3108 diagnostic_abort_on_error (dc
);
3111 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
3112 diagnostic context DC. */
3115 decode_d_option (const char *arg
, struct gcc_options
*opts
,
3116 location_t loc
, diagnostic_context
*dc
)
3124 opts
->x_flag_debug_asm
= 1;
3127 opts
->x_flag_print_asm_name
= 1;
3130 opts
->x_flag_dump_rtl_in_asm
= 1;
3131 opts
->x_flag_print_asm_name
= 1;
3134 opts
->x_rtl_dump_and_exit
= 1;
3136 case 'D': /* These are handled by the preprocessor. */
3143 setup_core_dumping (dc
);
3146 opts
->x_flag_dump_all_passed
= true;
3150 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
3155 /* Enable (or disable if VALUE is 0) a warning option ARG (language
3156 mask LANG_MASK, option handlers HANDLERS) as an error for option
3157 structures OPTS and OPTS_SET, diagnostic context DC (possibly
3158 NULL), location LOC. This is used by -Werror=. */
3161 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
3162 const struct cl_option_handlers
*handlers
,
3163 struct gcc_options
*opts
,
3164 struct gcc_options
*opts_set
,
3165 location_t loc
, diagnostic_context
*dc
)
3170 new_option
= XNEWVEC (char, strlen (arg
) + 2);
3171 new_option
[0] = 'W';
3172 strcpy (new_option
+ 1, arg
);
3173 option_index
= find_opt (new_option
, lang_mask
);
3174 if (option_index
== OPT_SPECIAL_unknown
)
3177 const char *hint
= op
.suggest_option (new_option
);
3179 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>;"
3180 " did you mean %<-%s%>?", value
? "" : "no-",
3181 arg
, new_option
, hint
);
3183 error_at (loc
, "%<-W%serror=%s%>: no option %<-%s%>",
3184 value
? "" : "no-", arg
, new_option
);
3186 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
3187 error_at (loc
, "%<-Werror=%s%>: %<-%s%> is not an option that "
3188 "controls warnings", arg
, new_option
);
3191 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
3192 const char *arg
= NULL
;
3194 if (cl_options
[option_index
].flags
& CL_JOINED
)
3195 arg
= new_option
+ cl_options
[option_index
].opt_len
;
3196 control_warning_option (option_index
, (int) kind
, arg
, value
,
3198 handlers
, opts
, opts_set
, dc
);
3203 /* Return malloced memory for the name of the option OPTION_INDEX
3204 which enabled a diagnostic (context CONTEXT), originally of type
3205 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
3209 option_name (diagnostic_context
*context
, int option_index
,
3210 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
3214 /* A warning classified as an error. */
3215 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
3216 && diag_kind
== DK_ERROR
)
3217 return concat (cl_options
[OPT_Werror_
].opt_text
,
3218 /* Skip over "-W". */
3219 cl_options
[option_index
].opt_text
+ 2,
3221 /* A warning with option. */
3223 return xstrdup (cl_options
[option_index
].opt_text
);
3225 /* A warning without option classified as an error. */
3226 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
3227 || diag_kind
== DK_WARNING
)
3228 && context
->warning_as_error_requested
)
3229 return xstrdup (cl_options
[OPT_Werror
].opt_text
);