1 /* Command line option handling.
2 Copyright (C) 2002-2018 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"
35 static void set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
);
37 /* Indexed by enum debug_info_type. */
38 const char *const debug_type_names
[] =
40 "none", "stabs", "dwarf-2", "xcoff", "vms"
43 /* Parse the -femit-struct-debug-detailed option value
44 and set the flag variables. */
46 #define MATCH( prefix, string ) \
47 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
48 ? ((string += sizeof prefix - 1), 1) : 0)
51 set_struct_debug_option (struct gcc_options
*opts
, location_t loc
,
54 /* various labels for comparison */
55 static const char dfn_lbl
[] = "dfn:", dir_lbl
[] = "dir:", ind_lbl
[] = "ind:";
56 static const char ord_lbl
[] = "ord:", gen_lbl
[] = "gen:";
57 static const char none_lbl
[] = "none", any_lbl
[] = "any";
58 static const char base_lbl
[] = "base", sys_lbl
[] = "sys";
60 enum debug_struct_file files
= DINFO_STRUCT_FILE_ANY
;
61 /* Default is to apply to as much as possible. */
62 enum debug_info_usage usage
= DINFO_USAGE_NUM_ENUMS
;
66 if (MATCH (dfn_lbl
, spec
))
67 usage
= DINFO_USAGE_DFN
;
68 else if (MATCH (dir_lbl
, spec
))
69 usage
= DINFO_USAGE_DIR_USE
;
70 else if (MATCH (ind_lbl
, spec
))
71 usage
= DINFO_USAGE_IND_USE
;
73 /* Generics or not? */
74 if (MATCH (ord_lbl
, spec
))
76 else if (MATCH (gen_lbl
, spec
))
79 /* What allowable environment? */
80 if (MATCH (none_lbl
, spec
))
81 files
= DINFO_STRUCT_FILE_NONE
;
82 else if (MATCH (any_lbl
, spec
))
83 files
= DINFO_STRUCT_FILE_ANY
;
84 else if (MATCH (sys_lbl
, spec
))
85 files
= DINFO_STRUCT_FILE_SYS
;
86 else if (MATCH (base_lbl
, spec
))
87 files
= DINFO_STRUCT_FILE_BASE
;
90 "argument %qs to %<-femit-struct-debug-detailed%> "
94 /* Effect the specification. */
95 if (usage
== DINFO_USAGE_NUM_ENUMS
)
99 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DFN
] = files
;
100 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
] = files
;
101 opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
] = files
;
105 opts
->x_debug_struct_generic
[DINFO_USAGE_DFN
] = files
;
106 opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
] = files
;
107 opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
] = files
;
113 opts
->x_debug_struct_ordinary
[usage
] = files
;
115 opts
->x_debug_struct_generic
[usage
] = files
;
119 set_struct_debug_option (opts
, loc
, spec
+1);
122 /* No more -femit-struct-debug-detailed specifications.
126 "argument %qs to %<-femit-struct-debug-detailed%> unknown",
128 if (opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
]
129 < opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
]
130 || opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
]
131 < opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
])
133 "%<-femit-struct-debug-detailed=dir:...%> must allow "
134 "at least as much as "
135 "%<-femit-struct-debug-detailed=ind:...%>");
139 /* Strip off a legitimate source ending from the input string NAME of
140 length LEN. Rather than having to know the names used by all of
141 our front ends, we strip off an ending of a period followed by
142 up to fource characters. (C++ uses ".cpp".) */
145 strip_off_ending (char *name
, int len
)
148 for (i
= 2; i
< 5 && len
> i
; i
++)
150 if (name
[len
- i
] == '.')
152 name
[len
- i
] = '\0';
158 /* Find the base name of a path, stripping off both directories and
159 a single final extension. */
161 base_of_path (const char *path
, const char **base_out
)
163 const char *base
= path
;
165 const char *p
= path
;
169 if (IS_DIR_SEPARATOR (c
))
184 /* What to print when a switch has no documentation. */
185 static const char undocumented_msg
[] = N_("This option lacks documentation.");
186 static const char use_diagnosed_msg
[] = N_("Uses of this option are diagnosed.");
188 typedef char *char_p
; /* For DEF_VEC_P. */
190 static void handle_param (struct gcc_options
*opts
,
191 struct gcc_options
*opts_set
, location_t loc
,
193 static void set_debug_level (enum debug_info_type type
, int extended
,
194 const char *arg
, struct gcc_options
*opts
,
195 struct gcc_options
*opts_set
,
197 static void set_fast_math_flags (struct gcc_options
*opts
, int set
);
198 static void decode_d_option (const char *arg
, struct gcc_options
*opts
,
199 location_t loc
, diagnostic_context
*dc
);
200 static void set_unsafe_math_optimizations_flags (struct gcc_options
*opts
,
202 static void enable_warning_as_error (const char *arg
, int value
,
203 unsigned int lang_mask
,
204 const struct cl_option_handlers
*handlers
,
205 struct gcc_options
*opts
,
206 struct gcc_options
*opts_set
,
208 diagnostic_context
*dc
);
210 /* Handle a back-end option; arguments and return value as for
214 target_handle_option (struct gcc_options
*opts
,
215 struct gcc_options
*opts_set
,
216 const struct cl_decoded_option
*decoded
,
217 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
219 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
220 diagnostic_context
*dc
, void (*) (void))
222 gcc_assert (dc
== global_dc
);
223 gcc_assert (kind
== DK_UNSPECIFIED
);
224 return targetm_common
.handle_option (opts
, opts_set
, decoded
, loc
);
227 /* Add comma-separated strings to a char_p vector. */
230 add_comma_separated_to_vector (void **pvec
, const char *arg
)
236 vec
<char_p
> *v
= (vec
<char_p
> *) *pvec
;
238 vec_check_alloc (v
, 1);
240 /* We never free this string. */
253 v
->safe_push (token_start
);
256 if (*r
== '\\' && r
[1] == ',')
264 if (*token_start
!= '\0')
265 v
->safe_push (token_start
);
270 /* Initialize opts_obstack. */
273 init_opts_obstack (void)
275 gcc_obstack_init (&opts_obstack
);
278 /* Initialize OPTS and OPTS_SET before using them in parsing options. */
281 init_options_struct (struct gcc_options
*opts
, struct gcc_options
*opts_set
)
283 size_t num_params
= get_num_compiler_params ();
285 /* Ensure that opts_obstack has already been initialized by the time
286 that we initialize any gcc_options instances (PR jit/68446). */
287 gcc_assert (opts_obstack
.chunk_size
> 0);
289 *opts
= global_options_init
;
292 memset (opts_set
, 0, sizeof (*opts_set
));
294 opts
->x_param_values
= XNEWVEC (int, num_params
);
297 opts_set
->x_param_values
= XCNEWVEC (int, num_params
);
299 init_param_values (opts
->x_param_values
);
301 /* Initialize whether `char' is signed. */
302 opts
->x_flag_signed_char
= DEFAULT_SIGNED_CHAR
;
303 /* Set this to a special "uninitialized" value. The actual default
304 is set after target options have been processed. */
305 opts
->x_flag_short_enums
= 2;
307 /* Initialize target_flags before default_options_optimization
308 so the latter can modify it. */
309 opts
->x_target_flags
= targetm_common
.default_target_flags
;
311 /* Some targets have ABI-specified unwind tables. */
312 opts
->x_flag_unwind_tables
= targetm_common
.unwind_tables_default
;
314 /* Some targets have other target-specific initialization. */
315 targetm_common
.option_init_struct (opts
);
318 /* Release any allocations owned by OPTS. */
321 finalize_options_struct (struct gcc_options
*opts
)
323 XDELETEVEC (opts
->x_param_values
);
326 /* If indicated by the optimization level LEVEL (-Os if SIZE is set,
327 -Ofast if FAST is set, -Og if DEBUG is set), apply the option DEFAULT_OPT
328 to OPTS and OPTS_SET, diagnostic context DC, location LOC, with language
329 mask LANG_MASK and option handlers HANDLERS. */
332 maybe_default_option (struct gcc_options
*opts
,
333 struct gcc_options
*opts_set
,
334 const struct default_options
*default_opt
,
335 int level
, bool size
, bool fast
, bool debug
,
336 unsigned int lang_mask
,
337 const struct cl_option_handlers
*handlers
,
339 diagnostic_context
*dc
)
341 const struct cl_option
*option
= &cl_options
[default_opt
->opt_index
];
345 gcc_assert (level
== 2);
347 gcc_assert (level
== 3);
349 gcc_assert (level
== 1);
351 switch (default_opt
->levels
)
357 case OPT_LEVELS_0_ONLY
:
358 enabled
= (level
== 0);
361 case OPT_LEVELS_1_PLUS
:
362 enabled
= (level
>= 1);
365 case OPT_LEVELS_1_PLUS_SPEED_ONLY
:
366 enabled
= (level
>= 1 && !size
&& !debug
);
369 case OPT_LEVELS_1_PLUS_NOT_DEBUG
:
370 enabled
= (level
>= 1 && !debug
);
373 case OPT_LEVELS_2_PLUS
:
374 enabled
= (level
>= 2);
377 case OPT_LEVELS_2_PLUS_SPEED_ONLY
:
378 enabled
= (level
>= 2 && !size
&& !debug
);
381 case OPT_LEVELS_3_PLUS
:
382 enabled
= (level
>= 3);
385 case OPT_LEVELS_3_PLUS_AND_SIZE
:
386 enabled
= (level
>= 3 || size
);
389 case OPT_LEVELS_SIZE
:
393 case OPT_LEVELS_FAST
:
397 case OPT_LEVELS_NONE
:
403 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
404 default_opt
->arg
, default_opt
->value
,
405 lang_mask
, DK_UNSPECIFIED
, loc
,
407 else if (default_opt
->arg
== NULL
408 && !option
->cl_reject_negative
)
409 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
410 default_opt
->arg
, !default_opt
->value
,
411 lang_mask
, DK_UNSPECIFIED
, loc
,
415 /* As indicated by the optimization level LEVEL (-Os if SIZE is set,
416 -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
417 OPTS and OPTS_SET, diagnostic context DC, location LOC, with
418 language mask LANG_MASK and option handlers HANDLERS. */
421 maybe_default_options (struct gcc_options
*opts
,
422 struct gcc_options
*opts_set
,
423 const struct default_options
*default_opts
,
424 int level
, bool size
, bool fast
, bool debug
,
425 unsigned int lang_mask
,
426 const struct cl_option_handlers
*handlers
,
428 diagnostic_context
*dc
)
432 for (i
= 0; default_opts
[i
].levels
!= OPT_LEVELS_NONE
; i
++)
433 maybe_default_option (opts
, opts_set
, &default_opts
[i
],
434 level
, size
, fast
, debug
,
435 lang_mask
, handlers
, loc
, dc
);
438 /* Table of options enabled by default at different levels.
439 Please keep this list sorted by level and alphabetized within
440 each level; this makes it easier to keep the documentation
443 static const struct default_options default_options_table
[] =
445 /* -O1 and -Og optimizations. */
446 { OPT_LEVELS_1_PLUS
, OPT_fcombine_stack_adjustments
, NULL
, 1 },
447 { OPT_LEVELS_1_PLUS
, OPT_fcompare_elim
, NULL
, 1 },
448 { OPT_LEVELS_1_PLUS
, OPT_fcprop_registers
, NULL
, 1 },
449 { OPT_LEVELS_1_PLUS
, OPT_fdefer_pop
, NULL
, 1 },
450 { OPT_LEVELS_1_PLUS
, OPT_fforward_propagate
, NULL
, 1 },
451 { OPT_LEVELS_1_PLUS
, OPT_fguess_branch_probability
, NULL
, 1 },
452 { OPT_LEVELS_1_PLUS
, OPT_fipa_profile
, NULL
, 1 },
453 { OPT_LEVELS_1_PLUS
, OPT_fipa_pure_const
, NULL
, 1 },
454 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference
, NULL
, 1 },
455 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference_addressable
, NULL
, 1 },
456 { OPT_LEVELS_1_PLUS
, OPT_fmerge_constants
, NULL
, 1 },
457 { OPT_LEVELS_1_PLUS
, OPT_fomit_frame_pointer
, NULL
, 1 },
458 { OPT_LEVELS_1_PLUS
, OPT_freorder_blocks
, NULL
, 1 },
459 { OPT_LEVELS_1_PLUS
, OPT_fshrink_wrap
, NULL
, 1 },
460 { OPT_LEVELS_1_PLUS
, OPT_fsplit_wide_types
, NULL
, 1 },
461 { OPT_LEVELS_1_PLUS
, OPT_ftree_builtin_call_dce
, NULL
, 1 },
462 { OPT_LEVELS_1_PLUS
, OPT_ftree_ccp
, NULL
, 1 },
463 { OPT_LEVELS_1_PLUS
, OPT_ftree_ch
, NULL
, 1 },
464 { OPT_LEVELS_1_PLUS
, OPT_ftree_coalesce_vars
, NULL
, 1 },
465 { OPT_LEVELS_1_PLUS
, OPT_ftree_copy_prop
, NULL
, 1 },
466 { OPT_LEVELS_1_PLUS
, OPT_ftree_dce
, NULL
, 1 },
467 { OPT_LEVELS_1_PLUS
, OPT_ftree_dominator_opts
, NULL
, 1 },
468 { OPT_LEVELS_1_PLUS
, OPT_ftree_dse
, NULL
, 1 },
469 { OPT_LEVELS_1_PLUS
, OPT_ftree_fre
, NULL
, 1 },
470 { OPT_LEVELS_1_PLUS
, OPT_ftree_sink
, NULL
, 1 },
471 { OPT_LEVELS_1_PLUS
, OPT_ftree_slsr
, NULL
, 1 },
472 { OPT_LEVELS_1_PLUS
, OPT_ftree_ter
, NULL
, 1 },
474 /* -O1 (and not -Og) optimizations. */
475 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fbranch_count_reg
, NULL
, 1 },
477 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fdelayed_branch
, NULL
, 1 },
479 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion
, NULL
, 1 },
480 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion2
, NULL
, 1 },
481 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_finline_functions_called_once
, NULL
, 1 },
482 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_invariants
, NULL
, 1 },
483 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fssa_phiopt
, NULL
, 1 },
484 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_bit_ccp
, NULL
, 1 },
485 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_sra
, NULL
, 1 },
486 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_pta
, NULL
, 1 },
488 /* -O2 and -Os optimizations. */
489 { OPT_LEVELS_2_PLUS
, OPT_fcaller_saves
, NULL
, 1 },
490 { OPT_LEVELS_2_PLUS
, OPT_fcode_hoisting
, NULL
, 1 },
491 { OPT_LEVELS_2_PLUS
, OPT_fcrossjumping
, NULL
, 1 },
492 { OPT_LEVELS_2_PLUS
, OPT_fcse_follow_jumps
, NULL
, 1 },
493 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize
, NULL
, 1 },
494 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize_speculatively
, NULL
, 1 },
495 { OPT_LEVELS_2_PLUS
, OPT_fexpensive_optimizations
, NULL
, 1 },
496 { OPT_LEVELS_2_PLUS
, OPT_fgcse
, NULL
, 1 },
497 { OPT_LEVELS_2_PLUS
, OPT_fhoist_adjacent_loads
, NULL
, 1 },
498 { OPT_LEVELS_2_PLUS
, OPT_findirect_inlining
, NULL
, 1 },
499 { OPT_LEVELS_2_PLUS
, OPT_finline_small_functions
, NULL
, 1 },
500 { OPT_LEVELS_2_PLUS
, OPT_fipa_bit_cp
, NULL
, 1 },
501 { OPT_LEVELS_2_PLUS
, OPT_fipa_cp
, NULL
, 1 },
502 { OPT_LEVELS_2_PLUS
, OPT_fipa_icf
, NULL
, 1 },
503 { OPT_LEVELS_2_PLUS
, OPT_fipa_ra
, NULL
, 1 },
504 { OPT_LEVELS_2_PLUS
, OPT_fipa_sra
, NULL
, 1 },
505 { OPT_LEVELS_2_PLUS
, OPT_fipa_vrp
, NULL
, 1 },
506 { OPT_LEVELS_2_PLUS
, OPT_fisolate_erroneous_paths_dereference
, NULL
, 1 },
507 { OPT_LEVELS_2_PLUS
, OPT_flra_remat
, NULL
, 1 },
508 { OPT_LEVELS_2_PLUS
, OPT_foptimize_sibling_calls
, NULL
, 1 },
509 { OPT_LEVELS_2_PLUS
, OPT_fpartial_inlining
, NULL
, 1 },
510 { OPT_LEVELS_2_PLUS
, OPT_fpeephole2
, NULL
, 1 },
511 { OPT_LEVELS_2_PLUS
, OPT_freorder_functions
, NULL
, 1 },
512 { OPT_LEVELS_2_PLUS
, OPT_frerun_cse_after_loop
, NULL
, 1 },
513 #ifdef INSN_SCHEDULING
514 { OPT_LEVELS_2_PLUS
, OPT_fschedule_insns2
, NULL
, 1 },
516 { OPT_LEVELS_2_PLUS
, OPT_fstrict_aliasing
, NULL
, 1 },
517 { OPT_LEVELS_2_PLUS
, OPT_fstore_merging
, NULL
, 1 },
518 { OPT_LEVELS_2_PLUS
, OPT_fthread_jumps
, NULL
, 1 },
519 { OPT_LEVELS_2_PLUS
, OPT_ftree_pre
, NULL
, 1 },
520 { OPT_LEVELS_2_PLUS
, OPT_ftree_switch_conversion
, NULL
, 1 },
521 { OPT_LEVELS_2_PLUS
, OPT_ftree_tail_merge
, NULL
, 1 },
522 { OPT_LEVELS_2_PLUS
, OPT_ftree_vrp
, NULL
, 1 },
523 { OPT_LEVELS_2_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_CHEAP
},
525 /* -O2 and -Os optimizations. */
526 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_functions
, NULL
, 1 },
527 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_jumps
, NULL
, 1 },
528 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_labels
, NULL
, 1 },
529 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_loops
, NULL
, 1 },
530 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_foptimize_strlen
, NULL
, 1 },
531 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_freorder_blocks_algorithm_
, NULL
,
532 REORDER_BLOCKS_ALGORITHM_STC
},
533 #ifdef INSN_SCHEDULING
534 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
535 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_fschedule_insns
, NULL
, 1 },
538 /* -O3 and -Os optimizations. */
539 /* Inlining of functions reducing size is a good idea with -Os
540 regardless of them being declared inline. */
541 { OPT_LEVELS_3_PLUS_AND_SIZE
, OPT_finline_functions
, NULL
, 1 },
543 /* -O3 optimizations. */
544 { OPT_LEVELS_3_PLUS
, OPT_fgcse_after_reload
, NULL
, 1 },
545 { OPT_LEVELS_3_PLUS
, OPT_fipa_cp_clone
, NULL
, 1 },
546 { OPT_LEVELS_3_PLUS
, OPT_floop_interchange
, NULL
, 1 },
547 { OPT_LEVELS_3_PLUS
, OPT_floop_unroll_and_jam
, NULL
, 1 },
548 { OPT_LEVELS_3_PLUS
, OPT_fpeel_loops
, NULL
, 1 },
549 { OPT_LEVELS_3_PLUS
, OPT_fpredictive_commoning
, NULL
, 1 },
550 { OPT_LEVELS_3_PLUS
, OPT_fsplit_loops
, NULL
, 1 },
551 { OPT_LEVELS_3_PLUS
, OPT_fsplit_paths
, NULL
, 1 },
552 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribute_patterns
, NULL
, 1 },
553 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribution
, NULL
, 1 },
554 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_vectorize
, NULL
, 1 },
555 { OPT_LEVELS_3_PLUS
, OPT_ftree_partial_pre
, NULL
, 1 },
556 { OPT_LEVELS_3_PLUS
, OPT_ftree_slp_vectorize
, NULL
, 1 },
557 { OPT_LEVELS_3_PLUS
, OPT_funswitch_loops
, NULL
, 1 },
558 { OPT_LEVELS_3_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_DYNAMIC
},
559 { OPT_LEVELS_3_PLUS
, OPT_fversion_loops_for_strides
, NULL
, 1 },
561 /* -Ofast adds optimizations to -O3. */
562 { OPT_LEVELS_FAST
, OPT_ffast_math
, NULL
, 1 },
564 { OPT_LEVELS_NONE
, 0, NULL
, 0 }
567 /* Default the options in OPTS and OPTS_SET based on the optimization
568 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
570 default_options_optimization (struct gcc_options
*opts
,
571 struct gcc_options
*opts_set
,
572 struct cl_decoded_option
*decoded_options
,
573 unsigned int decoded_options_count
,
575 unsigned int lang_mask
,
576 const struct cl_option_handlers
*handlers
,
577 diagnostic_context
*dc
)
581 bool openacc_mode
= false;
583 /* Scan to see what optimization level has been specified. That will
584 determine the default value of many flags. */
585 for (i
= 1; i
< decoded_options_count
; i
++)
587 struct cl_decoded_option
*opt
= &decoded_options
[i
];
588 switch (opt
->opt_index
)
591 if (*opt
->arg
== '\0')
593 opts
->x_optimize
= 1;
594 opts
->x_optimize_size
= 0;
595 opts
->x_optimize_fast
= 0;
596 opts
->x_optimize_debug
= 0;
600 const int optimize_val
= integral_argument (opt
->arg
);
601 if (optimize_val
== -1)
602 error_at (loc
, "argument to %<-O%> should be a non-negative "
603 "integer, %<g%>, %<s%> or %<fast%>");
606 opts
->x_optimize
= optimize_val
;
607 if ((unsigned int) opts
->x_optimize
> 255)
608 opts
->x_optimize
= 255;
609 opts
->x_optimize_size
= 0;
610 opts
->x_optimize_fast
= 0;
611 opts
->x_optimize_debug
= 0;
617 opts
->x_optimize_size
= 1;
619 /* Optimizing for size forces optimize to be 2. */
620 opts
->x_optimize
= 2;
621 opts
->x_optimize_fast
= 0;
622 opts
->x_optimize_debug
= 0;
626 /* -Ofast only adds flags to -O3. */
627 opts
->x_optimize_size
= 0;
628 opts
->x_optimize
= 3;
629 opts
->x_optimize_fast
= 1;
630 opts
->x_optimize_debug
= 0;
634 /* -Og selects optimization level 1. */
635 opts
->x_optimize_size
= 0;
636 opts
->x_optimize
= 1;
637 opts
->x_optimize_fast
= 0;
638 opts
->x_optimize_debug
= 1;
647 /* Ignore other options in this prescan. */
652 maybe_default_options (opts
, opts_set
, default_options_table
,
653 opts
->x_optimize
, opts
->x_optimize_size
,
654 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
655 lang_mask
, handlers
, loc
, dc
);
657 /* -O2 param settings. */
658 opt2
= (opts
->x_optimize
>= 2);
661 && !opts_set
->x_flag_ipa_pta
)
662 opts
->x_flag_ipa_pta
= true;
664 /* Track fields in field-sensitive alias analysis. */
665 maybe_set_param_value
666 (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
,
667 opt2
? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
),
668 opts
->x_param_values
, opts_set
->x_param_values
);
670 /* For -O1 only do loop invariant motion for very small loops. */
671 maybe_set_param_value
672 (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
,
673 opt2
? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
) : 1000,
674 opts
->x_param_values
, opts_set
->x_param_values
);
676 /* At -Ofast, allow store motion to introduce potential race conditions. */
677 maybe_set_param_value
678 (PARAM_ALLOW_STORE_DATA_RACES
,
679 opts
->x_optimize_fast
? 1
680 : default_param_value (PARAM_ALLOW_STORE_DATA_RACES
),
681 opts
->x_param_values
, opts_set
->x_param_values
);
683 if (opts
->x_optimize_size
)
684 /* We want to crossjump as much as possible. */
685 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
, 1,
686 opts
->x_param_values
, opts_set
->x_param_values
);
688 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
,
689 default_param_value (PARAM_MIN_CROSSJUMP_INSNS
),
690 opts
->x_param_values
, opts_set
->x_param_values
);
692 /* Restrict the amount of work combine does at -Og while retaining
693 most of its useful transforms. */
694 if (opts
->x_optimize_debug
)
695 maybe_set_param_value (PARAM_MAX_COMBINE_INSNS
, 2,
696 opts
->x_param_values
, opts_set
->x_param_values
);
698 /* Allow default optimizations to be specified on a per-machine basis. */
699 maybe_default_options (opts
, opts_set
,
700 targetm_common
.option_optimization_table
,
701 opts
->x_optimize
, opts
->x_optimize_size
,
702 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
703 lang_mask
, handlers
, loc
, dc
);
706 /* Control IPA optimizations based on different live patching LEVEL. */
708 control_options_for_live_patching (struct gcc_options
*opts
,
709 struct gcc_options
*opts_set
,
710 enum live_patching_level level
,
713 gcc_assert (level
> LIVE_PATCHING_NONE
);
717 case LIVE_PATCHING_INLINE_ONLY_STATIC
:
718 if (opts_set
->x_flag_ipa_cp_clone
&& opts
->x_flag_ipa_cp_clone
)
720 "%<-fipa-cp-clone%> is incompatible with "
721 "%<-flive-patching=inline-only-static%>");
723 opts
->x_flag_ipa_cp_clone
= 0;
725 if (opts_set
->x_flag_ipa_sra
&& opts
->x_flag_ipa_sra
)
727 "%<-fipa-sra%> is incompatible with "
728 "%<-flive-patching=inline-only-static%>");
730 opts
->x_flag_ipa_sra
= 0;
732 if (opts_set
->x_flag_partial_inlining
&& opts
->x_flag_partial_inlining
)
734 "%<-fpartial-inlining%> is incompatible with "
735 "%<-flive-patching=inline-only-static%>");
737 opts
->x_flag_partial_inlining
= 0;
739 if (opts_set
->x_flag_ipa_cp
&& opts
->x_flag_ipa_cp
)
741 "%<-fipa-cp%> is incompatible with "
742 "%<-flive-patching=inline-only-static%>");
744 opts
->x_flag_ipa_cp
= 0;
747 case LIVE_PATCHING_INLINE_CLONE
:
748 /* live patching should disable whole-program optimization. */
749 if (opts_set
->x_flag_whole_program
&& opts
->x_flag_whole_program
)
751 "%<-fwhole-program%> is incompatible with "
752 "%<-flive-patching=inline-only-static|inline-clone%>");
754 opts
->x_flag_whole_program
= 0;
756 /* visibility change should be excluded by !flag_whole_program
757 && !in_lto_p && !flag_ipa_cp_clone && !flag_ipa_sra
758 && !flag_partial_inlining. */
760 if (opts_set
->x_flag_ipa_pta
&& opts
->x_flag_ipa_pta
)
762 "%<-fipa-pta%> is incompatible with "
763 "%<-flive-patching=inline-only-static|inline-clone%>");
765 opts
->x_flag_ipa_pta
= 0;
767 if (opts_set
->x_flag_ipa_reference
&& opts
->x_flag_ipa_reference
)
769 "%<-fipa-reference%> is incompatible with "
770 "%<-flive-patching=inline-only-static|inline-clone%>");
772 opts
->x_flag_ipa_reference
= 0;
774 if (opts_set
->x_flag_ipa_ra
&& opts
->x_flag_ipa_ra
)
776 "%<-fipa-ra%> is incompatible with "
777 "%<-flive-patching=inline-only-static|inline-clone%>");
779 opts
->x_flag_ipa_ra
= 0;
781 if (opts_set
->x_flag_ipa_icf
&& opts
->x_flag_ipa_icf
)
783 "%<-fipa-icf%> is incompatible with "
784 "%<-flive-patching=inline-only-static|inline-clone%>");
786 opts
->x_flag_ipa_icf
= 0;
788 if (opts_set
->x_flag_ipa_icf_functions
&& opts
->x_flag_ipa_icf_functions
)
790 "%<-fipa-icf-functions%> is incompatible with "
791 "%<-flive-patching=inline-only-static|inline-clone%>");
793 opts
->x_flag_ipa_icf_functions
= 0;
795 if (opts_set
->x_flag_ipa_icf_variables
&& opts
->x_flag_ipa_icf_variables
)
797 "%<-fipa-icf-variables%> is incompatible with "
798 "%<-flive-patching=inline-only-static|inline-clone%>");
800 opts
->x_flag_ipa_icf_variables
= 0;
802 if (opts_set
->x_flag_ipa_bit_cp
&& opts
->x_flag_ipa_bit_cp
)
804 "%<-fipa-bit-cp%> is incompatible with "
805 "%<-flive-patching=inline-only-static|inline-clone%>");
807 opts
->x_flag_ipa_bit_cp
= 0;
809 if (opts_set
->x_flag_ipa_vrp
&& opts
->x_flag_ipa_vrp
)
811 "%<-fipa-vrp%> is incompatible with "
812 "%<-flive-patching=inline-only-static|inline-clone%>");
814 opts
->x_flag_ipa_vrp
= 0;
816 if (opts_set
->x_flag_ipa_pure_const
&& opts
->x_flag_ipa_pure_const
)
818 "%<-fipa-pure-const%> is incompatible with "
819 "%<-flive-patching=inline-only-static|inline-clone%>");
821 opts
->x_flag_ipa_pure_const
= 0;
823 /* FIXME: disable unreachable code removal. */
825 /* discovery of functions/variables with no address taken. */
826 if (opts_set
->x_flag_ipa_reference_addressable
827 && opts
->x_flag_ipa_reference_addressable
)
829 "%<-fipa-reference-addressable%> is incompatible with "
830 "%<-flive-patching=inline-only-static|inline-clone%>");
832 opts
->x_flag_ipa_reference_addressable
= 0;
834 /* ipa stack alignment propagation. */
835 if (opts_set
->x_flag_ipa_stack_alignment
836 && opts
->x_flag_ipa_stack_alignment
)
838 "%<-fipa-stack-alignment%> is incompatible with "
839 "%<-flive-patching=inline-only-static|inline-clone%>");
841 opts
->x_flag_ipa_stack_alignment
= 0;
848 /* After all options at LOC have been read into OPTS and OPTS_SET,
849 finalize settings of those options and diagnose incompatible
852 finish_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
855 enum unwind_info_type ui_except
;
857 if (opts
->x_dump_base_name
858 && ! opts
->x_dump_base_name_prefixed
)
860 const char *sep
= opts
->x_dump_base_name
;
863 if (IS_DIR_SEPARATOR (*sep
))
867 /* If dump_base_path contains subdirectories, don't prepend
869 else if (opts
->x_dump_dir_name
)
870 /* We have a DUMP_DIR_NAME, prepend that. */
871 opts
->x_dump_base_name
= opts_concat (opts
->x_dump_dir_name
,
872 opts
->x_dump_base_name
, NULL
);
873 else if (opts
->x_aux_base_name
874 && strcmp (opts
->x_aux_base_name
, HOST_BIT_BUCKET
) != 0)
875 /* AUX_BASE_NAME is set and is not the bit bucket. If it
876 contains a directory component, prepend those directories.
877 Typically this places things in the same directory as the
880 const char *aux_base
;
882 base_of_path (opts
->x_aux_base_name
, &aux_base
);
883 if (opts
->x_aux_base_name
!= aux_base
)
885 int dir_len
= aux_base
- opts
->x_aux_base_name
;
886 char *new_dump_base_name
887 = XOBNEWVEC (&opts_obstack
, char,
888 strlen (opts
->x_dump_base_name
) + dir_len
+ 1);
890 /* Copy directory component from OPTS->X_AUX_BASE_NAME. */
891 memcpy (new_dump_base_name
, opts
->x_aux_base_name
, dir_len
);
892 /* Append existing OPTS->X_DUMP_BASE_NAME. */
893 strcpy (new_dump_base_name
+ dir_len
, opts
->x_dump_base_name
);
894 opts
->x_dump_base_name
= new_dump_base_name
;
898 /* It is definitely prefixed now. */
899 opts
->x_dump_base_name_prefixed
= true;
902 /* Handle related options for unit-at-a-time, toplevel-reorder, and
904 if (!opts
->x_flag_unit_at_a_time
)
906 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
907 error_at (loc
, "section anchors must be disabled when unit-at-a-time "
909 opts
->x_flag_section_anchors
= 0;
910 if (opts
->x_flag_toplevel_reorder
== 1)
911 error_at (loc
, "toplevel reorder must be disabled when unit-at-a-time "
913 opts
->x_flag_toplevel_reorder
= 0;
916 /* -fself-test depends on the state of the compiler prior to
917 compiling anything. Ideally it should be run on an empty source
918 file. However, in case we get run with actual source, assume
919 -fsyntax-only which will inhibit any compiler initialization
920 which may confuse the self tests. */
921 if (opts
->x_flag_self_test
)
922 opts
->x_flag_syntax_only
= 1;
924 if (opts
->x_flag_tm
&& opts
->x_flag_non_call_exceptions
)
925 sorry ("transactional memory is not supported with non-call exceptions");
927 /* Unless the user has asked for section anchors, we disable toplevel
928 reordering at -O0 to disable transformations that might be surprising
929 to end users and to get -fno-toplevel-reorder tested. */
930 if (!opts
->x_optimize
931 && opts
->x_flag_toplevel_reorder
== 2
932 && !(opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
))
934 opts
->x_flag_toplevel_reorder
= 0;
935 opts
->x_flag_section_anchors
= 0;
937 if (!opts
->x_flag_toplevel_reorder
)
939 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
940 error_at (loc
, "section anchors must be disabled when toplevel reorder"
942 opts
->x_flag_section_anchors
= 0;
945 if (!opts
->x_flag_opts_finished
)
947 /* We initialize opts->x_flag_pie to -1 so that targets can set a
949 if (opts
->x_flag_pie
== -1)
951 /* We initialize opts->x_flag_pic to -1 so that we can tell if
952 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
953 if (opts
->x_flag_pic
== -1)
954 opts
->x_flag_pie
= DEFAULT_FLAG_PIE
;
956 opts
->x_flag_pie
= 0;
958 /* If -fPIE or -fpie is used, turn on PIC. */
959 if (opts
->x_flag_pie
)
960 opts
->x_flag_pic
= opts
->x_flag_pie
;
961 else if (opts
->x_flag_pic
== -1)
962 opts
->x_flag_pic
= 0;
963 if (opts
->x_flag_pic
&& !opts
->x_flag_pie
)
964 opts
->x_flag_shlib
= 1;
965 opts
->x_flag_opts_finished
= true;
968 /* We initialize opts->x_flag_stack_protect to -1 so that targets
969 can set a default value. */
970 if (opts
->x_flag_stack_protect
== -1)
971 opts
->x_flag_stack_protect
= DEFAULT_FLAG_SSP
;
973 if (opts
->x_optimize
== 0)
975 /* Inlining does not work if not optimizing,
976 so force it not to be done. */
977 opts
->x_warn_inline
= 0;
978 opts
->x_flag_no_inline
= 1;
981 /* The optimization to partition hot and cold basic blocks into separate
982 sections of the .o and executable files does not work (currently)
983 with exception handling. This is because there is no support for
984 generating unwind info. If opts->x_flag_exceptions is turned on
985 we need to turn off the partitioning optimization. */
987 ui_except
= targetm_common
.except_unwind_info (opts
);
989 if (opts
->x_flag_exceptions
990 && opts
->x_flag_reorder_blocks_and_partition
991 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
993 if (opts_set
->x_flag_reorder_blocks_and_partition
)
995 "%<-freorder-blocks-and-partition%> does not work "
996 "with exceptions on this architecture");
997 opts
->x_flag_reorder_blocks_and_partition
= 0;
998 opts
->x_flag_reorder_blocks
= 1;
1001 /* If user requested unwind info, then turn off the partitioning
1004 if (opts
->x_flag_unwind_tables
1005 && !targetm_common
.unwind_tables_default
1006 && opts
->x_flag_reorder_blocks_and_partition
1007 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1009 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1011 "%<-freorder-blocks-and-partition%> does not support "
1012 "unwind info on this architecture");
1013 opts
->x_flag_reorder_blocks_and_partition
= 0;
1014 opts
->x_flag_reorder_blocks
= 1;
1017 /* If the target requested unwind info, then turn off the partitioning
1018 optimization with a different message. Likewise, if the target does not
1019 support named sections. */
1021 if (opts
->x_flag_reorder_blocks_and_partition
1022 && (!targetm_common
.have_named_sections
1023 || (opts
->x_flag_unwind_tables
1024 && targetm_common
.unwind_tables_default
1025 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
1027 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1029 "%<-freorder-blocks-and-partition%> does not work "
1030 "on this architecture");
1031 opts
->x_flag_reorder_blocks_and_partition
= 0;
1032 opts
->x_flag_reorder_blocks
= 1;
1036 /* Pipelining of outer loops is only possible when general pipelining
1037 capabilities are requested. */
1038 if (!opts
->x_flag_sel_sched_pipelining
)
1039 opts
->x_flag_sel_sched_pipelining_outer_loops
= 0;
1041 if (opts
->x_flag_conserve_stack
)
1043 maybe_set_param_value (PARAM_LARGE_STACK_FRAME
, 100,
1044 opts
->x_param_values
, opts_set
->x_param_values
);
1045 maybe_set_param_value (PARAM_STACK_FRAME_GROWTH
, 40,
1046 opts
->x_param_values
, opts_set
->x_param_values
);
1049 if (opts
->x_flag_lto
)
1052 opts
->x_flag_generate_lto
= 1;
1054 /* When generating IL, do not operate in whole-program mode.
1055 Otherwise, symbols will be privatized too early, causing link
1057 opts
->x_flag_whole_program
= 0;
1059 error_at (loc
, "LTO support has not been enabled in this configuration");
1061 if (!opts
->x_flag_fat_lto_objects
1062 && (!HAVE_LTO_PLUGIN
1063 || (opts_set
->x_flag_use_linker_plugin
1064 && !opts
->x_flag_use_linker_plugin
)))
1066 if (opts_set
->x_flag_fat_lto_objects
)
1067 error_at (loc
, "%<-fno-fat-lto-objects%> are supported only with "
1069 opts
->x_flag_fat_lto_objects
= 1;
1073 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
1074 default value if they choose based on other options. */
1075 if (opts
->x_flag_split_stack
== -1)
1076 opts
->x_flag_split_stack
= 0;
1077 else if (opts
->x_flag_split_stack
)
1079 if (!targetm_common
.supports_split_stack (true, opts
))
1081 error_at (loc
, "%<-fsplit-stack%> is not supported by "
1082 "this compiler configuration");
1083 opts
->x_flag_split_stack
= 0;
1087 /* If stack splitting is turned on, and the user did not explicitly
1088 request function partitioning, turn off partitioning, as it
1089 confuses the linker when trying to handle partitioned split-stack
1090 code that calls a non-split-stack functions. But if partitioning
1091 was turned on explicitly just hope for the best. */
1092 if (opts
->x_flag_split_stack
1093 && opts
->x_flag_reorder_blocks_and_partition
1094 && !opts_set
->x_flag_reorder_blocks_and_partition
)
1095 opts
->x_flag_reorder_blocks_and_partition
= 0;
1097 if (opts
->x_flag_reorder_blocks_and_partition
1098 && !opts_set
->x_flag_reorder_functions
)
1099 opts
->x_flag_reorder_functions
= 1;
1101 /* Tune vectorization related parametees according to cost model. */
1102 if (opts
->x_flag_vect_cost_model
== VECT_COST_MODEL_CHEAP
)
1104 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS
,
1105 6, opts
->x_param_values
, opts_set
->x_param_values
);
1106 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS
,
1107 0, opts
->x_param_values
, opts_set
->x_param_values
);
1108 maybe_set_param_value (PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT
,
1109 0, opts
->x_param_values
, opts_set
->x_param_values
);
1112 /* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
1114 if ((!opts
->x_flag_tree_loop_vectorize
&& !opts
->x_flag_tree_slp_vectorize
)
1115 || !opts
->x_flag_tree_loop_if_convert
)
1116 maybe_set_param_value (PARAM_MAX_STORES_TO_SINK
, 0,
1117 opts
->x_param_values
, opts_set
->x_param_values
);
1119 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
1120 if (opts
->x_dwarf_split_debug_info
)
1121 opts
->x_debug_generate_pub_sections
= 2;
1123 if ((opts
->x_flag_sanitize
1124 & (SANITIZE_USER_ADDRESS
| SANITIZE_KERNEL_ADDRESS
)) == 0)
1126 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_COMPARE
)
1128 "%<-fsanitize=pointer-compare%> must be combined with "
1129 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1130 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_SUBTRACT
)
1132 "%<-fsanitize=pointer-subtract%> must be combined with "
1133 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1136 /* Userspace and kernel ASan conflict with each other. */
1137 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
1138 && (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
))
1140 "%<-fsanitize=address%> is incompatible with "
1141 "%<-fsanitize=kernel-address%>");
1143 /* And with TSan. */
1144 if ((opts
->x_flag_sanitize
& SANITIZE_ADDRESS
)
1145 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
1147 "%<-fsanitize=address%> and %<-fsanitize=kernel-address%> "
1148 "are incompatible with %<-fsanitize=thread%>");
1150 if ((opts
->x_flag_sanitize
& SANITIZE_LEAK
)
1151 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
1153 "%<-fsanitize=leak%> is incompatible with %<-fsanitize=thread%>");
1155 /* Check error recovery for -fsanitize-recover option. */
1156 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1157 if ((opts
->x_flag_sanitize_recover
& sanitizer_opts
[i
].flag
)
1158 && !sanitizer_opts
[i
].can_recover
)
1159 error_at (loc
, "%<-fsanitize-recover=%s%> is not supported",
1160 sanitizer_opts
[i
].name
);
1162 /* When instrumenting the pointers, we don't want to remove
1163 the null pointer checks. */
1164 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
1165 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
1166 opts
->x_flag_delete_null_pointer_checks
= 0;
1168 /* Aggressive compiler optimizations may cause false negatives. */
1169 if (opts
->x_flag_sanitize
& ~(SANITIZE_LEAK
| SANITIZE_UNREACHABLE
))
1170 opts
->x_flag_aggressive_loop_optimizations
= 0;
1172 /* Enable -fsanitize-address-use-after-scope if address sanitizer is
1174 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
1175 && !opts_set
->x_flag_sanitize_address_use_after_scope
)
1176 opts
->x_flag_sanitize_address_use_after_scope
= true;
1178 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1180 if (opts
->x_flag_sanitize_address_use_after_scope
)
1182 if (opts
->x_flag_stack_reuse
!= SR_NONE
1183 && opts_set
->x_flag_stack_reuse
!= SR_NONE
)
1185 "%<-fsanitize-address-use-after-scope%> requires "
1186 "%<-fstack-reuse=none%> option");
1188 opts
->x_flag_stack_reuse
= SR_NONE
;
1191 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
) && opts
->x_flag_tm
)
1192 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1194 if ((opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) && opts
->x_flag_tm
)
1195 sorry ("transactional memory is not supported with "
1196 "%<-fsanitize=kernel-address%>");
1198 /* Currently live patching is not support for LTO. */
1199 if (opts
->x_flag_live_patching
&& opts
->x_flag_lto
)
1200 sorry ("live patching is not supported with LTO");
1202 /* Control IPA optimizations based on different -flive-patching level. */
1203 if (opts
->x_flag_live_patching
)
1205 control_options_for_live_patching (opts
, opts_set
,
1206 opts
->x_flag_live_patching
,
1211 #define LEFT_COLUMN 27
1213 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1214 followed by word-wrapped HELP in a second column. */
1216 wrap_help (const char *help
,
1218 unsigned int item_width
,
1219 unsigned int columns
)
1221 unsigned int col_width
= LEFT_COLUMN
;
1222 unsigned int remaining
, room
, len
;
1224 remaining
= strlen (help
);
1228 room
= columns
- 3 - MAX (col_width
, item_width
);
1237 for (i
= 0; help
[i
]; i
++)
1239 if (i
>= room
&& len
!= remaining
)
1243 else if ((help
[i
] == '-' || help
[i
] == '/')
1244 && help
[i
+ 1] != ' '
1245 && i
> 0 && ISALPHA (help
[i
- 1]))
1250 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1252 while (help
[len
] == ' ')
1260 /* Data structure used to print list of valid option values. */
1262 struct option_help_tuple
1264 option_help_tuple (int code
, vec
<const char *> values
):
1265 m_code (code
), m_values (values
)
1268 /* Code of an option. */
1271 /* List of possible values. */
1272 vec
<const char *> m_values
;
1275 /* Print help for a specific front-end, etc. */
1277 print_filtered_help (unsigned int include_flags
,
1278 unsigned int exclude_flags
,
1279 unsigned int any_flags
,
1280 unsigned int columns
,
1281 struct gcc_options
*opts
,
1282 unsigned int lang_mask
)
1287 bool displayed
= false;
1290 if (include_flags
== CL_PARAMS
)
1292 for (i
= 0; i
< LAST_PARAM
; i
++)
1294 const char *param
= compiler_params
[i
].option
;
1296 help
= compiler_params
[i
].help
;
1297 if (help
== NULL
|| *help
== '\0')
1299 if (exclude_flags
& CL_UNDOCUMENTED
)
1301 help
= undocumented_msg
;
1304 /* Get the translation. */
1307 if (!opts
->x_quiet_flag
)
1309 snprintf (new_help
, sizeof (new_help
),
1310 _("default %d minimum %d maximum %d"),
1311 compiler_params
[i
].default_value
,
1312 compiler_params
[i
].min_value
,
1313 compiler_params
[i
].max_value
);
1316 wrap_help (help
, param
, strlen (param
), columns
);
1322 if (!opts
->x_help_printed
)
1323 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1325 if (!opts
->x_help_enum_printed
)
1326 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1328 auto_vec
<option_help_tuple
> help_tuples
;
1330 for (i
= 0; i
< cl_options_count
; i
++)
1332 const struct cl_option
*option
= cl_options
+ i
;
1337 if (include_flags
== 0
1338 || ((option
->flags
& include_flags
) != include_flags
))
1340 if ((option
->flags
& any_flags
) == 0)
1344 /* Skip unwanted switches. */
1345 if ((option
->flags
& exclude_flags
) != 0)
1348 /* The driver currently prints its own help text. */
1349 if ((option
->flags
& CL_DRIVER
) != 0
1350 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1351 | CL_COMMON
| CL_TARGET
)) == 0)
1355 /* Skip switches that have already been printed. */
1356 if (opts
->x_help_printed
[i
])
1359 opts
->x_help_printed
[i
] = true;
1361 help
= option
->help
;
1364 if (exclude_flags
& CL_UNDOCUMENTED
)
1367 help
= undocumented_msg
;
1370 if (option
->alias_target
< N_OPTS
1371 && cl_options
[option
->alias_target
].help
)
1373 if (help
== undocumented_msg
)
1375 /* For undocumented options that are aliases for other options
1376 that are documented, point the reader to the other option in
1377 preference of the former. */
1378 snprintf (new_help
, sizeof new_help
,
1379 _("Same as %s. Use the latter option instead."),
1380 cl_options
[option
->alias_target
].opt_text
);
1384 /* For documented options with aliases, mention the aliased
1385 option's name for reference. */
1386 snprintf (new_help
, sizeof new_help
,
1387 _("%s Same as %s."),
1388 help
, cl_options
[option
->alias_target
].opt_text
);
1394 if (option
->warn_message
)
1396 /* Mention that the use of the option will trigger a warning. */
1397 if (help
== new_help
)
1398 snprintf (new_help
+ strlen (new_help
),
1399 sizeof new_help
- strlen (new_help
),
1400 " %s", _(use_diagnosed_msg
));
1402 snprintf (new_help
, sizeof new_help
,
1403 "%s %s", help
, _(use_diagnosed_msg
));
1408 /* Get the translation. */
1411 /* Find the gap between the name of the
1412 option and its descriptive text. */
1413 tab
= strchr (help
, '\t');
1422 opt
= option
->opt_text
;
1426 /* With the -Q option enabled we change the descriptive text associated
1427 with an option to be an indication of its current setting. */
1428 if (!opts
->x_quiet_flag
)
1430 void *flag_var
= option_flag_var (i
, opts
);
1432 if (len
< (LEFT_COLUMN
+ 2))
1433 strcpy (new_help
, "\t\t");
1435 strcpy (new_help
, "\t");
1437 if (flag_var
!= NULL
1438 && option
->var_type
!= CLVC_DEFER
)
1440 if (option
->flags
& CL_JOINED
)
1442 if (option
->var_type
== CLVC_STRING
)
1444 if (* (const char **) flag_var
!= NULL
)
1445 snprintf (new_help
+ strlen (new_help
),
1446 sizeof (new_help
) - strlen (new_help
),
1447 "%s", * (const char **) flag_var
);
1449 else if (option
->var_type
== CLVC_ENUM
)
1451 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1453 const char *arg
= NULL
;
1455 value
= e
->get (flag_var
);
1456 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1458 arg
= _("[default]");
1459 snprintf (new_help
+ strlen (new_help
),
1460 sizeof (new_help
) - strlen (new_help
),
1464 sprintf (new_help
+ strlen (new_help
),
1465 "%d", * (int *) flag_var
);
1468 strcat (new_help
, option_enabled (i
, opts
)
1469 ? _("[enabled]") : _("[disabled]"));
1475 if (option
->range_max
!= -1)
1478 snprintf (b
, sizeof (b
), "<%d,%d>", option
->range_min
,
1480 opt
= concat (opt
, b
, NULL
);
1484 wrap_help (help
, opt
, len
, columns
);
1487 if (option
->var_type
== CLVC_ENUM
1488 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1489 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1492 vec
<const char *> option_values
1493 = targetm_common
.get_valid_option_values (i
, NULL
);
1494 if (!option_values
.is_empty ())
1495 help_tuples
.safe_push (option_help_tuple (i
, option_values
));
1501 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1504 printf (_(" No options with the desired characteristics were found\n"));
1509 /* PR 31349: Tell the user how to see all of the
1510 options supported by a specific front end. */
1511 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1512 if ((1U << i
) & langs
)
1513 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1514 lang_names
[i
], lang_names
[i
]);
1518 else if (! displayed
)
1519 printf (_(" All options with the desired characteristics have already been displayed\n"));
1523 /* Print details of enumerated option arguments, if those
1524 enumerations have help text headings provided. If no help text
1525 is provided, presume that the possible values are listed in the
1526 help text for the relevant options. */
1527 for (i
= 0; i
< cl_enums_count
; i
++)
1529 unsigned int j
, pos
;
1531 if (opts
->x_help_enum_printed
[i
] != 1)
1533 if (cl_enums
[i
].help
== NULL
)
1535 printf (" %s\n ", _(cl_enums
[i
].help
));
1537 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1539 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1541 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1543 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1553 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1558 opts
->x_help_enum_printed
[i
] = 2;
1561 for (unsigned i
= 0; i
< help_tuples
.length (); i
++)
1563 const struct cl_option
*option
= cl_options
+ help_tuples
[i
].m_code
;
1564 printf (" Known valid arguments for %s option:\n ", option
->opt_text
);
1565 for (unsigned j
= 0; j
< help_tuples
[i
].m_values
.length (); j
++)
1566 printf (" %s", help_tuples
[i
].m_values
[j
]);
1571 /* Display help for a specified type of option.
1572 The options must have ALL of the INCLUDE_FLAGS set
1573 ANY of the flags in the ANY_FLAGS set
1574 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1575 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1577 print_specific_help (unsigned int include_flags
,
1578 unsigned int exclude_flags
,
1579 unsigned int any_flags
,
1580 struct gcc_options
*opts
,
1581 unsigned int lang_mask
)
1583 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1584 const char * description
= NULL
;
1585 const char * descrip_extra
= "";
1589 /* Sanity check: Make sure that we do not have more
1590 languages than we have bits available to enumerate them. */
1591 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1593 /* If we have not done so already, obtain
1594 the desired maximum width of the output. */
1595 if (opts
->x_help_columns
== 0)
1597 opts
->x_help_columns
= get_terminal_width ();
1598 if (opts
->x_help_columns
== INT_MAX
)
1599 /* Use a reasonable default. */
1600 opts
->x_help_columns
= 80;
1603 /* Decide upon the title for the options that we are going to display. */
1604 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1606 switch (flag
& include_flags
)
1613 description
= _("The following options are target specific");
1616 description
= _("The following options control compiler warning messages");
1618 case CL_OPTIMIZATION
:
1619 description
= _("The following options control optimizations");
1622 description
= _("The following options are language-independent");
1625 description
= _("The --param option recognizes the following as parameters");
1628 if (i
>= cl_lang_count
)
1630 if (exclude_flags
& all_langs_mask
)
1631 description
= _("The following options are specific to just the language ");
1633 description
= _("The following options are supported by the language ");
1634 descrip_extra
= lang_names
[i
];
1639 if (description
== NULL
)
1643 if (include_flags
& CL_UNDOCUMENTED
)
1644 description
= _("The following options are not documented");
1645 else if (include_flags
& CL_SEPARATE
)
1646 description
= _("The following options take separate arguments");
1647 else if (include_flags
& CL_JOINED
)
1648 description
= _("The following options take joined arguments");
1651 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1658 if (any_flags
& all_langs_mask
)
1659 description
= _("The following options are language-related");
1661 description
= _("The following options are language-independent");
1665 printf ("%s%s:\n", description
, descrip_extra
);
1666 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
1667 opts
->x_help_columns
, opts
, lang_mask
);
1670 /* Enable FDO-related flags. */
1673 enable_fdo_optimizations (struct gcc_options
*opts
,
1674 struct gcc_options
*opts_set
,
1677 if (!opts_set
->x_flag_branch_probabilities
)
1678 opts
->x_flag_branch_probabilities
= value
;
1679 if (!opts_set
->x_flag_profile_values
)
1680 opts
->x_flag_profile_values
= value
;
1681 if (!opts_set
->x_flag_unroll_loops
)
1682 opts
->x_flag_unroll_loops
= value
;
1683 if (!opts_set
->x_flag_peel_loops
)
1684 opts
->x_flag_peel_loops
= value
;
1685 if (!opts_set
->x_flag_tracer
)
1686 opts
->x_flag_tracer
= value
;
1687 if (!opts_set
->x_flag_value_profile_transformations
)
1688 opts
->x_flag_value_profile_transformations
= value
;
1689 if (!opts_set
->x_flag_inline_functions
)
1690 opts
->x_flag_inline_functions
= value
;
1691 if (!opts_set
->x_flag_ipa_cp
)
1692 opts
->x_flag_ipa_cp
= value
;
1693 if (!opts_set
->x_flag_ipa_cp_clone
1694 && value
&& opts
->x_flag_ipa_cp
)
1695 opts
->x_flag_ipa_cp_clone
= value
;
1696 if (!opts_set
->x_flag_ipa_bit_cp
1697 && value
&& opts
->x_flag_ipa_cp
)
1698 opts
->x_flag_ipa_bit_cp
= value
;
1699 if (!opts_set
->x_flag_predictive_commoning
)
1700 opts
->x_flag_predictive_commoning
= value
;
1701 if (!opts_set
->x_flag_split_loops
)
1702 opts
->x_flag_split_loops
= value
;
1703 if (!opts_set
->x_flag_unswitch_loops
)
1704 opts
->x_flag_unswitch_loops
= value
;
1705 if (!opts_set
->x_flag_gcse_after_reload
)
1706 opts
->x_flag_gcse_after_reload
= value
;
1707 if (!opts_set
->x_flag_tree_loop_vectorize
)
1708 opts
->x_flag_tree_loop_vectorize
= value
;
1709 if (!opts_set
->x_flag_tree_slp_vectorize
)
1710 opts
->x_flag_tree_slp_vectorize
= value
;
1711 if (!opts_set
->x_flag_vect_cost_model
)
1712 opts
->x_flag_vect_cost_model
= VECT_COST_MODEL_DYNAMIC
;
1713 if (!opts_set
->x_flag_tree_loop_distribute_patterns
)
1714 opts
->x_flag_tree_loop_distribute_patterns
= value
;
1717 /* -f{,no-}sanitize{,-recover}= suboptions. */
1718 const struct sanitizer_opts_s sanitizer_opts
[] =
1720 #define SANITIZER_OPT(name, flags, recover) \
1721 { #name, flags, sizeof #name - 1, recover }
1722 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true),
1723 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
1725 SANITIZER_OPT (pointer
-compare
, SANITIZE_POINTER_COMPARE
, true),
1726 SANITIZER_OPT (pointer
-subtract
, SANITIZE_POINTER_SUBTRACT
, true),
1727 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false),
1728 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false),
1729 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true),
1730 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true),
1731 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true),
1732 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true),
1733 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true),
1734 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false),
1735 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true),
1736 SANITIZER_OPT (return, SANITIZE_RETURN
, false),
1737 SANITIZER_OPT (null
, SANITIZE_NULL
, true),
1738 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true),
1739 SANITIZER_OPT (bool, SANITIZE_BOOL
, true),
1740 SANITIZER_OPT (enum, SANITIZE_ENUM
, true),
1741 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true),
1742 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true),
1743 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true),
1744 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true),
1745 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true),
1746 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true),
1747 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
1749 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true),
1750 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true),
1751 SANITIZER_OPT (pointer
-overflow
, SANITIZE_POINTER_OVERFLOW
, true),
1752 SANITIZER_OPT (builtin
, SANITIZE_BUILTIN
, true),
1753 SANITIZER_OPT (all
, ~0U, true),
1754 #undef SANITIZER_OPT
1755 { NULL
, 0U, 0UL, false }
1758 /* -f{,no-}sanitize-coverage= suboptions. */
1759 const struct sanitizer_opts_s coverage_sanitizer_opts
[] =
1761 #define COVERAGE_SANITIZER_OPT(name, flags) \
1762 { #name, flags, sizeof #name - 1, true }
1763 COVERAGE_SANITIZER_OPT (trace
-pc
, SANITIZE_COV_TRACE_PC
),
1764 COVERAGE_SANITIZER_OPT (trace
-cmp
, SANITIZE_COV_TRACE_CMP
),
1765 #undef COVERAGE_SANITIZER_OPT
1766 { NULL
, 0U, 0UL, false }
1769 /* A struct for describing a run of chars within a string. */
1771 struct string_fragment
1773 string_fragment (const char *start
, size_t len
)
1774 : m_start (start
), m_len (len
) {}
1776 const char *m_start
;
1780 /* Specialization of edit_distance_traits for string_fragment,
1781 for use by get_closest_sanitizer_option. */
1784 struct edit_distance_traits
<const string_fragment
&>
1786 static size_t get_length (const string_fragment
&fragment
)
1788 return fragment
.m_len
;
1791 static const char *get_string (const string_fragment
&fragment
)
1793 return fragment
.m_start
;
1797 /* Given ARG, an unrecognized sanitizer option, return the best
1798 matching sanitizer option, or NULL if there isn't one.
1799 OPTS is array of candidate sanitizer options.
1800 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or
1801 OPT_fsanitize_coverage_.
1802 VALUE is non-zero for the regular form of the option, zero
1803 for the "no-" form (e.g. "-fno-sanitize-recover="). */
1806 get_closest_sanitizer_option (const string_fragment
&arg
,
1807 const struct sanitizer_opts_s
*opts
,
1808 enum opt_code code
, int value
)
1810 best_match
<const string_fragment
&, const char*> bm (arg
);
1811 for (int i
= 0; opts
[i
].name
!= NULL
; ++i
)
1813 /* -fsanitize=all is not valid, so don't offer it. */
1814 if (code
== OPT_fsanitize_
1815 && opts
[i
].flag
== ~0U
1819 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
1820 don't offer the non-recoverable options. */
1821 if (code
== OPT_fsanitize_recover_
1822 && !opts
[i
].can_recover
1826 bm
.consider (opts
[i
].name
);
1828 return bm
.get_best_meaningful_candidate ();
1831 /* Parse comma separated sanitizer suboptions from P for option SCODE,
1832 adjust previous FLAGS and return new ones. If COMPLAIN is false,
1833 don't issue diagnostics. */
1836 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
1837 unsigned int flags
, int value
, bool complain
)
1839 enum opt_code code
= (enum opt_code
) scode
;
1841 const struct sanitizer_opts_s
*opts
;
1842 if (code
== OPT_fsanitize_coverage_
)
1843 opts
= coverage_sanitizer_opts
;
1845 opts
= sanitizer_opts
;
1851 const char *comma
= strchr (p
, ',');
1863 /* Check to see if the string matches an option class name. */
1864 for (i
= 0; opts
[i
].name
!= NULL
; ++i
)
1865 if (len
== opts
[i
].len
&& memcmp (p
, opts
[i
].name
, len
) == 0)
1867 /* Handle both -fsanitize and -fno-sanitize cases. */
1868 if (value
&& opts
[i
].flag
== ~0U)
1870 if (code
== OPT_fsanitize_
)
1873 error_at (loc
, "%<-fsanitize=all%> option is not valid");
1876 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
1877 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
1881 /* Do not enable -fsanitize-recover=unreachable and
1882 -fsanitize-recover=return if -fsanitize-recover=undefined
1884 if (code
== OPT_fsanitize_recover_
1885 && opts
[i
].flag
== SANITIZE_UNDEFINED
)
1886 flags
|= (SANITIZE_UNDEFINED
1887 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
1889 flags
|= opts
[i
].flag
;
1892 flags
&= ~opts
[i
].flag
;
1897 if (! found
&& complain
)
1900 = get_closest_sanitizer_option (string_fragment (p
, len
),
1904 if (code
== OPT_fsanitize_recover_
)
1905 suffix
= "-recover";
1906 else if (code
== OPT_fsanitize_coverage_
)
1907 suffix
= "-coverage";
1913 "unrecognized argument to -f%ssanitize%s= option: %q.*s;"
1914 " did you mean %qs?",
1916 suffix
, (int) len
, p
, hint
);
1919 "unrecognized argument to -f%ssanitize%s= option: %q.*s",
1921 suffix
, (int) len
, p
);
1931 /* Parse string values of no_sanitize attribute passed in VALUE.
1932 Values are separated with comma. */
1935 parse_no_sanitize_attribute (char *value
)
1937 unsigned int flags
= 0;
1939 char *q
= strtok (value
, ",");
1943 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1944 if (strcmp (sanitizer_opts
[i
].name
, q
) == 0)
1946 flags
|= sanitizer_opts
[i
].flag
;
1947 if (sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
1948 flags
|= SANITIZE_UNDEFINED_NONDEFAULT
;
1952 if (sanitizer_opts
[i
].name
== NULL
)
1953 warning (OPT_Wattributes
,
1954 "%<%s%> attribute directive ignored", q
);
1956 q
= strtok (NULL
, ",");
1962 /* Parse -falign-NAME format for a FLAG value. Return individual
1963 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
1964 set, print error message at LOC location. */
1967 parse_and_check_align_values (const char *flag
,
1969 auto_vec
<unsigned> &result_values
,
1973 char *str
= xstrdup (flag
);
1974 for (char *p
= strtok (str
, ":"); p
; p
= strtok (NULL
, ":"))
1977 int v
= strtol (p
, &end
, 10);
1978 if (*end
!= '\0' || v
< 0)
1981 error_at (loc
, "invalid arguments for %<-falign-%s%> option: %qs",
1987 result_values
.safe_push ((unsigned)v
);
1992 /* Check that we have a correct number of values. */
1994 unsigned max_valid_values
= 4;
1996 unsigned max_valid_values
= 2;
1999 if (result_values
.is_empty ()
2000 || result_values
.length () > max_valid_values
)
2003 error_at (loc
, "invalid number of arguments for %<-falign-%s%> "
2004 "option: %qs", name
, flag
);
2008 for (unsigned i
= 0; i
< result_values
.length (); i
++)
2009 if (result_values
[i
] > MAX_CODE_ALIGN_VALUE
)
2012 error_at (loc
, "%<-falign-%s%> is not between 0 and %d",
2013 name
, MAX_CODE_ALIGN_VALUE
);
2020 /* Check that alignment value FLAG for -falign-NAME is valid at a given
2024 check_alignment_argument (location_t loc
, const char *flag
, const char *name
)
2026 auto_vec
<unsigned> align_result
;
2027 parse_and_check_align_values (flag
, name
, align_result
, true, loc
);
2030 /* Handle target- and language-independent options. Return zero to
2031 generate an "unknown option" message. Only options that need
2032 extra handling need to be listed here; if you simply want
2033 DECODED->value assigned to a variable, it happens automatically. */
2036 common_handle_option (struct gcc_options
*opts
,
2037 struct gcc_options
*opts_set
,
2038 const struct cl_decoded_option
*decoded
,
2039 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
2041 const struct cl_option_handlers
*handlers
,
2042 diagnostic_context
*dc
,
2043 void (*target_option_override_hook
) (void))
2045 size_t scode
= decoded
->opt_index
;
2046 const char *arg
= decoded
->arg
;
2047 HOST_WIDE_INT value
= decoded
->value
;
2048 enum opt_code code
= (enum opt_code
) scode
;
2050 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
2055 handle_param (opts
, opts_set
, loc
, arg
);
2060 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
2061 unsigned int undoc_mask
;
2064 if (lang_mask
== CL_DRIVER
)
2067 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
2070 target_option_override_hook ();
2071 /* First display any single language specific options. */
2072 for (i
= 0; i
< cl_lang_count
; i
++)
2074 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
2076 /* Next display any multi language specific options. */
2077 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
2078 /* Then display any remaining, non-language options. */
2079 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
2081 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
2082 opts
->x_exit_after_options
= true;
2086 case OPT__target_help
:
2087 if (lang_mask
== CL_DRIVER
)
2090 target_option_override_hook ();
2091 print_specific_help (CL_TARGET
, CL_UNDOCUMENTED
, 0, opts
, lang_mask
);
2092 opts
->x_exit_after_options
= true;
2097 const char *a
= arg
;
2098 unsigned int include_flags
= 0;
2099 /* Note - by default we include undocumented options when listing
2100 specific classes. If you only want to see documented options
2101 then add ",^undocumented" to the --help= option. E.g.:
2103 --help=target,^undocumented */
2104 unsigned int exclude_flags
= 0;
2106 if (lang_mask
== CL_DRIVER
)
2109 /* Walk along the argument string, parsing each word in turn.
2111 arg = [^]{word}[,{arg}]
2112 word = {optimizers|target|warnings|undocumented|
2113 params|common|<language>} */
2123 { "optimizers", CL_OPTIMIZATION
},
2124 { "target", CL_TARGET
},
2125 { "warnings", CL_WARNING
},
2126 { "undocumented", CL_UNDOCUMENTED
},
2127 { "params", CL_PARAMS
},
2128 { "joined", CL_JOINED
},
2129 { "separate", CL_SEPARATE
},
2130 { "common", CL_COMMON
},
2133 unsigned int *pflags
;
2135 unsigned int lang_flag
, specific_flag
;
2144 error_at (loc
, "missing argument to %qs", "--help=^");
2147 pflags
= &exclude_flags
;
2150 pflags
= &include_flags
;
2152 comma
= strchr (a
, ',');
2163 /* Check to see if the string matches an option class name. */
2164 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
2165 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
2167 specific_flag
= specifics
[i
].flag
;
2171 /* Check to see if the string matches a language name.
2172 Note - we rely upon the alpha-sorted nature of the entries in
2173 the lang_names array, specifically that shorter names appear
2174 before their longer variants. (i.e. C before C++). That way
2175 when we are attempting to match --help=c for example we will
2176 match with C first and not C++. */
2177 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
2178 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
2180 lang_flag
= 1U << i
;
2184 if (specific_flag
!= 0)
2187 *pflags
|= specific_flag
;
2190 /* The option's argument matches both the start of a
2191 language name and the start of an option class name.
2192 We have a special case for when the user has
2193 specified "--help=c", but otherwise we have to issue
2195 if (strncasecmp (a
, "c", len
) == 0)
2196 *pflags
|= lang_flag
;
2199 "--help argument %q.*s is ambiguous, "
2200 "please be more specific",
2204 else if (lang_flag
!= 0)
2205 *pflags
|= lang_flag
;
2208 "unrecognized argument to --help= option: %q.*s",
2218 target_option_override_hook ();
2219 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
2222 opts
->x_exit_after_options
= true;
2227 if (lang_mask
== CL_DRIVER
)
2230 opts
->x_exit_after_options
= true;
2233 case OPT__completion_
:
2236 case OPT_fsanitize_
:
2237 opts
->x_flag_sanitize
2238 = parse_sanitizer_options (arg
, loc
, code
,
2239 opts
->x_flag_sanitize
, value
, true);
2241 /* Kernel ASan implies normal ASan but does not yet support
2243 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
2245 maybe_set_param_value (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD
,
2246 0, opts
->x_param_values
,
2247 opts_set
->x_param_values
);
2248 maybe_set_param_value (PARAM_ASAN_GLOBALS
, 0, opts
->x_param_values
,
2249 opts_set
->x_param_values
);
2250 maybe_set_param_value (PARAM_ASAN_STACK
, 0, opts
->x_param_values
,
2251 opts_set
->x_param_values
);
2252 maybe_set_param_value (PARAM_ASAN_PROTECT_ALLOCAS
, 0,
2253 opts
->x_param_values
,
2254 opts_set
->x_param_values
);
2255 maybe_set_param_value (PARAM_ASAN_USE_AFTER_RETURN
, 0,
2256 opts
->x_param_values
,
2257 opts_set
->x_param_values
);
2261 case OPT_fsanitize_recover_
:
2262 opts
->x_flag_sanitize_recover
2263 = parse_sanitizer_options (arg
, loc
, code
,
2264 opts
->x_flag_sanitize_recover
, value
, true);
2267 case OPT_fasan_shadow_offset_
:
2271 case OPT_fsanitize_address_use_after_scope
:
2272 opts
->x_flag_sanitize_address_use_after_scope
= value
;
2275 case OPT_fsanitize_recover
:
2277 opts
->x_flag_sanitize_recover
2278 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)
2279 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2281 opts
->x_flag_sanitize_recover
2282 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2285 case OPT_fsanitize_coverage_
:
2286 opts
->x_flag_sanitize_coverage
2287 = parse_sanitizer_options (arg
, loc
, code
,
2288 opts
->x_flag_sanitize_coverage
, value
, true);
2295 /* Currently handled in a prescan. */
2299 dc
->warning_as_error_requested
= value
;
2303 if (lang_mask
== CL_DRIVER
)
2306 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
2307 opts
, opts_set
, loc
, dc
);
2310 case OPT_Wfatal_errors
:
2311 dc
->fatal_errors
= value
;
2314 case OPT_Wstack_usage_
:
2315 opts
->x_flag_stack_usage_info
= value
!= -1;
2318 case OPT_Wstrict_aliasing
:
2319 set_Wstrict_aliasing (opts
, value
);
2322 case OPT_Wstrict_overflow
:
2323 opts
->x_warn_strict_overflow
= (value
2324 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2328 case OPT_Wsystem_headers
:
2329 dc
->dc_warn_system_headers
= value
;
2333 opts
->x_flag_gen_aux_info
= 1;
2336 case OPT_auxbase_strip
:
2338 char *tmp
= xstrdup (arg
);
2339 strip_off_ending (tmp
, strlen (tmp
));
2341 opts
->x_aux_base_name
= tmp
;
2348 decode_d_option (arg
, opts
, loc
, dc
);
2351 case OPT_fcall_used_
:
2352 case OPT_fcall_saved_
:
2360 case OPT_fdbg_cnt_list
:
2362 opts
->x_exit_after_options
= true;
2365 case OPT_fdebug_prefix_map_
:
2366 case OPT_ffile_prefix_map_
:
2370 case OPT_fdiagnostics_show_location_
:
2371 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2374 case OPT_fdiagnostics_show_caret
:
2375 dc
->show_caret
= value
;
2378 case OPT_fdiagnostics_show_labels
:
2379 dc
->show_labels_p
= value
;
2382 case OPT_fdiagnostics_show_line_numbers
:
2383 dc
->show_line_numbers_p
= value
;
2386 case OPT_fdiagnostics_color_
:
2387 diagnostic_color_init (dc
, value
);
2390 case OPT_fdiagnostics_format_
:
2391 diagnostic_output_format_init (dc
,
2392 (enum diagnostics_output_format
)value
);
2395 case OPT_fdiagnostics_parseable_fixits
:
2396 dc
->parseable_fixits_p
= value
;
2399 case OPT_fdiagnostics_show_option
:
2400 dc
->show_option_requested
= value
;
2403 case OPT_fdiagnostics_minimum_margin_width_
:
2404 dc
->min_margin_width
= value
;
2411 case OPT_ffast_math
:
2412 set_fast_math_flags (opts
, value
);
2415 case OPT_funsafe_math_optimizations
:
2416 set_unsafe_math_optimizations_flags (opts
, value
);
2423 case OPT_finline_limit_
:
2424 set_param_value ("max-inline-insns-single", value
/ 2,
2425 opts
->x_param_values
, opts_set
->x_param_values
);
2426 set_param_value ("max-inline-insns-auto", value
/ 2,
2427 opts
->x_param_values
, opts_set
->x_param_values
);
2430 case OPT_finstrument_functions_exclude_function_list_
:
2431 add_comma_separated_to_vector
2432 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2435 case OPT_finstrument_functions_exclude_file_list_
:
2436 add_comma_separated_to_vector
2437 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2440 case OPT_fmessage_length_
:
2441 pp_set_line_maximum_length (dc
->printer
, value
);
2442 diagnostic_set_caret_max_width (dc
, value
);
2446 case OPT_fopt_info_
:
2452 const char *p
= arg
;
2453 opts
->x_flag_disable_hsa
= true;
2456 const char *comma
= strchr (p
, ',');
2458 if ((strncmp (p
, "disable", 7) == 0)
2459 && (p
[7] == ',' || p
[7] == '\0'))
2461 opts
->x_flag_disable_hsa
= true;
2465 if ((strncmp (p
, "hsa", 3) == 0)
2466 && (p
[3] == ',' || p
[3] == '\0'))
2469 opts
->x_flag_disable_hsa
= false;
2471 sorry ("HSA has not been enabled during configuration");
2481 #ifndef ACCEL_COMPILER
2482 case OPT_foffload_abi_
:
2483 error_at (loc
, "%<-foffload-abi%> option can be specified only for "
2484 "offload compiler");
2488 case OPT_fpack_struct_
:
2489 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2491 "structure alignment must be a small power of two, not %wu",
2494 opts
->x_initial_max_fld_align
= value
;
2498 case OPT_fplugin_arg_
:
2502 case OPT_fprofile_use_
:
2503 opts
->x_profile_data_prefix
= xstrdup (arg
);
2504 opts
->x_flag_profile_use
= true;
2506 /* No break here - do -fprofile-use processing. */
2508 case OPT_fprofile_use
:
2509 enable_fdo_optimizations (opts
, opts_set
, value
);
2510 if (!opts_set
->x_flag_profile_reorder_functions
)
2511 opts
->x_flag_profile_reorder_functions
= value
;
2512 /* Indirect call profiling should do all useful transformations
2513 speculative devirtualization does. */
2514 if (!opts_set
->x_flag_devirtualize_speculatively
2515 && opts
->x_flag_value_profile_transformations
)
2516 opts
->x_flag_devirtualize_speculatively
= false;
2519 case OPT_fauto_profile_
:
2520 opts
->x_auto_profile_file
= xstrdup (arg
);
2521 opts
->x_flag_auto_profile
= true;
2523 /* No break here - do -fauto-profile processing. */
2525 case OPT_fauto_profile
:
2526 enable_fdo_optimizations (opts
, opts_set
, value
);
2527 if (!opts_set
->x_flag_profile_correction
)
2528 opts
->x_flag_profile_correction
= value
;
2529 maybe_set_param_value (
2530 PARAM_EARLY_INLINER_MAX_ITERATIONS
, 10,
2531 opts
->x_param_values
, opts_set
->x_param_values
);
2534 case OPT_fprofile_generate_
:
2535 opts
->x_profile_data_prefix
= xstrdup (arg
);
2537 /* No break here - do -fprofile-generate processing. */
2539 case OPT_fprofile_generate
:
2540 if (!opts_set
->x_profile_arc_flag
)
2541 opts
->x_profile_arc_flag
= value
;
2542 if (!opts_set
->x_flag_profile_values
)
2543 opts
->x_flag_profile_values
= value
;
2544 if (!opts_set
->x_flag_inline_functions
)
2545 opts
->x_flag_inline_functions
= value
;
2546 if (!opts_set
->x_flag_ipa_bit_cp
)
2547 opts
->x_flag_ipa_bit_cp
= value
;
2548 /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
2549 quadratic. Disable the pass until better memory representation
2551 if (!opts_set
->x_flag_ipa_reference
)
2552 opts
->x_flag_ipa_reference
= false;
2555 case OPT_fpatchable_function_entry_
:
2557 char *patch_area_arg
= xstrdup (arg
);
2558 char *comma
= strchr (patch_area_arg
, ',');
2562 function_entry_patch_area_size
=
2563 integral_argument (patch_area_arg
);
2564 function_entry_patch_area_start
=
2565 integral_argument (comma
+ 1);
2569 function_entry_patch_area_size
=
2570 integral_argument (patch_area_arg
);
2571 function_entry_patch_area_start
= 0;
2573 if (function_entry_patch_area_size
< 0
2574 || function_entry_patch_area_start
< 0
2575 || function_entry_patch_area_size
2576 < function_entry_patch_area_start
)
2577 error ("invalid arguments for %<-fpatchable_function_entry%>");
2578 free (patch_area_arg
);
2582 case OPT_ftree_vectorize
:
2583 /* Automatically sets -ftree-loop-vectorize and
2584 -ftree-slp-vectorize. Nothing more to do here. */
2586 case OPT_fshow_column
:
2587 dc
->show_column
= value
;
2590 case OPT_frandom_seed
:
2591 /* The real switch is -fno-random-seed. */
2597 case OPT_frandom_seed_
:
2601 case OPT_fsched_verbose_
:
2602 #ifdef INSN_SCHEDULING
2603 /* Handled with Var in common.opt. */
2609 case OPT_fsched_stalled_insns_
:
2610 opts
->x_flag_sched_stalled_insns
= value
;
2611 if (opts
->x_flag_sched_stalled_insns
== 0)
2612 opts
->x_flag_sched_stalled_insns
= -1;
2615 case OPT_fsched_stalled_insns_dep_
:
2616 opts
->x_flag_sched_stalled_insns_dep
= value
;
2619 case OPT_fstack_check_
:
2620 if (!strcmp (arg
, "no"))
2621 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
2622 else if (!strcmp (arg
, "generic"))
2623 /* This is the old stack checking method. */
2624 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2625 ? FULL_BUILTIN_STACK_CHECK
2626 : GENERIC_STACK_CHECK
;
2627 else if (!strcmp (arg
, "specific"))
2628 /* This is the new stack checking method. */
2629 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2630 ? FULL_BUILTIN_STACK_CHECK
2631 : STACK_CHECK_STATIC_BUILTIN
2632 ? STATIC_BUILTIN_STACK_CHECK
2633 : GENERIC_STACK_CHECK
;
2635 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
2638 case OPT_fstack_limit
:
2639 /* The real switch is -fno-stack-limit. */
2645 case OPT_fstack_limit_register_
:
2646 case OPT_fstack_limit_symbol_
:
2650 case OPT_fstack_usage
:
2651 opts
->x_flag_stack_usage
= value
;
2652 opts
->x_flag_stack_usage_info
= value
!= 0;
2656 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
2661 if (arg
&& strlen (arg
) != 0)
2663 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
2664 "use %<-gdwarf-%s%> for DWARF version "
2665 "or %<-gdwarf -g%s%> for debug level", arg
, arg
, arg
);
2669 value
= opts
->x_dwarf_version
;
2673 if (value
< 2 || value
> 5)
2674 error_at (loc
, "dwarf version %wu is not supported", value
);
2676 opts
->x_dwarf_version
= value
;
2677 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
2680 case OPT_gsplit_dwarf
:
2681 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, "", opts
, opts_set
,
2686 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
2691 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
, opts
, opts_set
,
2696 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2701 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
, opts
, opts_set
,
2707 /* Handled completely via specs. */
2710 case OPT_pedantic_errors
:
2711 dc
->pedantic_errors
= 1;
2712 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
2714 handlers
, opts
, opts_set
,
2719 opts
->x_flag_lto
= value
? "" : NULL
;
2723 dc
->dc_inhibit_warnings
= true;
2726 case OPT_fmax_errors_
:
2727 dc
->max_errors
= value
;
2730 case OPT_fuse_ld_bfd
:
2731 case OPT_fuse_ld_gold
:
2732 case OPT_fuse_ld_lld
:
2733 case OPT_fuse_linker_plugin
:
2734 /* No-op. Used by the driver and passed to us because it starts with f.*/
2739 opts
->x_flag_trapv
= 0;
2744 opts
->x_flag_wrapv
= 0;
2747 case OPT_fstrict_overflow
:
2748 opts
->x_flag_wrapv
= !value
;
2749 opts
->x_flag_wrapv_pointer
= !value
;
2751 opts
->x_flag_trapv
= 0;
2755 opts
->x_flag_ipa_icf_functions
= value
;
2756 opts
->x_flag_ipa_icf_variables
= value
;
2759 case OPT_falign_loops_
:
2760 check_alignment_argument (loc
, arg
, "loops");
2763 case OPT_falign_jumps_
:
2764 check_alignment_argument (loc
, arg
, "jumps");
2767 case OPT_falign_labels_
:
2768 check_alignment_argument (loc
, arg
, "labels");
2771 case OPT_falign_functions_
:
2772 check_alignment_argument (loc
, arg
, "functions");
2776 /* If the flag was handled in a standard way, assume the lack of
2777 processing here is intentional. */
2778 gcc_assert (option_flag_var (scode
, opts
));
2782 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
2787 /* Handle --param NAME=VALUE. */
2789 handle_param (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2790 location_t loc
, const char *carg
)
2795 arg
= xstrdup (carg
);
2796 equal
= strchr (arg
, '=');
2798 error_at (loc
, "%s: --param arguments should be of the form NAME=VALUE",
2804 enum compiler_param index
;
2805 if (!find_param (arg
, &index
))
2807 const char *suggestion
= find_param_fuzzy (arg
);
2809 error_at (loc
, "invalid --param name %qs; did you mean %qs?",
2812 error_at (loc
, "invalid --param name %qs", arg
);
2816 if (!param_string_value_p (index
, equal
+ 1, &value
))
2817 value
= integral_argument (equal
+ 1);
2820 error_at (loc
, "invalid --param value %qs", equal
+ 1);
2822 set_param_value (arg
, value
,
2823 opts
->x_param_values
, opts_set
->x_param_values
);
2830 /* Used to set the level of strict aliasing warnings in OPTS,
2831 when no level is specified (i.e., when -Wstrict-aliasing, and not
2832 -Wstrict-aliasing=level was given).
2833 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2834 and 0 otherwise. After calling this function, wstrict_aliasing will be
2835 set to the default value of -Wstrict_aliasing=level, currently 3. */
2837 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
2839 gcc_assert (onoff
== 0 || onoff
== 1);
2841 opts
->x_warn_strict_aliasing
= 3;
2843 opts
->x_warn_strict_aliasing
= 0;
2846 /* The following routines are useful in setting all the flags that
2847 -ffast-math and -fno-fast-math imply. */
2849 set_fast_math_flags (struct gcc_options
*opts
, int set
)
2851 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
2853 opts
->x_flag_unsafe_math_optimizations
= set
;
2854 set_unsafe_math_optimizations_flags (opts
, set
);
2856 if (!opts
->frontend_set_flag_finite_math_only
)
2857 opts
->x_flag_finite_math_only
= set
;
2858 if (!opts
->frontend_set_flag_errno_math
)
2859 opts
->x_flag_errno_math
= !set
;
2862 if (opts
->frontend_set_flag_excess_precision_cmdline
2863 == EXCESS_PRECISION_DEFAULT
)
2864 opts
->x_flag_excess_precision_cmdline
2865 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
2866 if (!opts
->frontend_set_flag_signaling_nans
)
2867 opts
->x_flag_signaling_nans
= 0;
2868 if (!opts
->frontend_set_flag_rounding_math
)
2869 opts
->x_flag_rounding_math
= 0;
2870 if (!opts
->frontend_set_flag_cx_limited_range
)
2871 opts
->x_flag_cx_limited_range
= 1;
2875 /* When -funsafe-math-optimizations is set the following
2876 flags are set as well. */
2878 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
2880 if (!opts
->frontend_set_flag_trapping_math
)
2881 opts
->x_flag_trapping_math
= !set
;
2882 if (!opts
->frontend_set_flag_signed_zeros
)
2883 opts
->x_flag_signed_zeros
= !set
;
2884 if (!opts
->frontend_set_flag_associative_math
)
2885 opts
->x_flag_associative_math
= set
;
2886 if (!opts
->frontend_set_flag_reciprocal_math
)
2887 opts
->x_flag_reciprocal_math
= set
;
2890 /* Return true iff flags in OPTS are set as if -ffast-math. */
2892 fast_math_flags_set_p (const struct gcc_options
*opts
)
2894 return (!opts
->x_flag_trapping_math
2895 && opts
->x_flag_unsafe_math_optimizations
2896 && opts
->x_flag_finite_math_only
2897 && !opts
->x_flag_signed_zeros
2898 && !opts
->x_flag_errno_math
2899 && opts
->x_flag_excess_precision_cmdline
2900 == EXCESS_PRECISION_FAST
);
2903 /* Return true iff flags are set as if -ffast-math but using the flags stored
2904 in the struct cl_optimization structure. */
2906 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
2908 return (!opt
->x_flag_trapping_math
2909 && opt
->x_flag_unsafe_math_optimizations
2910 && opt
->x_flag_finite_math_only
2911 && !opt
->x_flag_signed_zeros
2912 && !opt
->x_flag_errno_math
);
2915 /* Handle a debug output -g switch for options OPTS
2916 (OPTS_SET->x_write_symbols storing whether a debug type was passed
2917 explicitly), location LOC. EXTENDED is true or false to support
2918 extended output (2 is special and means "-ggdb" was given). */
2920 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
,
2921 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2924 opts
->x_use_gnu_debug_info_extensions
= extended
;
2926 if (type
== NO_DEBUG
)
2928 if (opts
->x_write_symbols
== NO_DEBUG
)
2930 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
2934 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
2935 opts
->x_write_symbols
= DWARF2_DEBUG
;
2936 #elif defined DBX_DEBUGGING_INFO
2937 opts
->x_write_symbols
= DBX_DEBUG
;
2941 if (opts
->x_write_symbols
== NO_DEBUG
)
2942 warning_at (loc
, 0, "target system does not support debug output");
2947 /* Does it conflict with an already selected type? */
2948 if (opts_set
->x_write_symbols
!= NO_DEBUG
2949 && opts
->x_write_symbols
!= NO_DEBUG
2950 && type
!= opts
->x_write_symbols
)
2951 error_at (loc
, "debug format %qs conflicts with prior selection",
2952 debug_type_names
[type
]);
2953 opts
->x_write_symbols
= type
;
2954 opts_set
->x_write_symbols
= type
;
2957 /* A debug flag without a level defaults to level 2.
2958 If off or at level 1, set it to level 2, but if already
2959 at level 3, don't lower it. */
2962 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
2963 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
2967 int argval
= integral_argument (arg
);
2969 error_at (loc
, "unrecognized debug output level %qs", arg
);
2970 else if (argval
> 3)
2971 error_at (loc
, "debug output level %qs is too high", arg
);
2973 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
2977 /* Arrange to dump core on error for diagnostic context DC. (The
2978 regular error message is still printed first, except in the case of
2982 setup_core_dumping (diagnostic_context
*dc
)
2985 signal (SIGABRT
, SIG_DFL
);
2987 #if defined(HAVE_SETRLIMIT)
2990 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
2991 fatal_error (input_location
, "getting core file size maximum limit: %m");
2992 rlim
.rlim_cur
= rlim
.rlim_max
;
2993 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
2994 fatal_error (input_location
,
2995 "setting core file size limit to maximum: %m");
2998 diagnostic_abort_on_error (dc
);
3001 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
3002 diagnostic context DC. */
3005 decode_d_option (const char *arg
, struct gcc_options
*opts
,
3006 location_t loc
, diagnostic_context
*dc
)
3014 opts
->x_flag_debug_asm
= 1;
3017 opts
->x_flag_print_asm_name
= 1;
3020 opts
->x_flag_dump_rtl_in_asm
= 1;
3021 opts
->x_flag_print_asm_name
= 1;
3024 opts
->x_rtl_dump_and_exit
= 1;
3026 case 'D': /* These are handled by the preprocessor. */
3033 setup_core_dumping (dc
);
3036 opts
->x_flag_dump_all_passed
= true;
3040 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
3045 /* Enable (or disable if VALUE is 0) a warning option ARG (language
3046 mask LANG_MASK, option handlers HANDLERS) as an error for option
3047 structures OPTS and OPTS_SET, diagnostic context DC (possibly
3048 NULL), location LOC. This is used by -Werror=. */
3051 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
3052 const struct cl_option_handlers
*handlers
,
3053 struct gcc_options
*opts
,
3054 struct gcc_options
*opts_set
,
3055 location_t loc
, diagnostic_context
*dc
)
3060 new_option
= XNEWVEC (char, strlen (arg
) + 2);
3061 new_option
[0] = 'W';
3062 strcpy (new_option
+ 1, arg
);
3063 option_index
= find_opt (new_option
, lang_mask
);
3064 if (option_index
== OPT_SPECIAL_unknown
)
3065 error_at (loc
, "-Werror=%s: no option -%s", arg
, new_option
);
3066 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
3067 error_at (loc
, "-Werror=%s: -%s is not an option that controls warnings",
3071 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
3072 const char *arg
= NULL
;
3074 if (cl_options
[option_index
].flags
& CL_JOINED
)
3075 arg
= new_option
+ cl_options
[option_index
].opt_len
;
3076 control_warning_option (option_index
, (int) kind
, arg
, value
,
3078 handlers
, opts
, opts_set
, dc
);
3083 /* Return malloced memory for the name of the option OPTION_INDEX
3084 which enabled a diagnostic (context CONTEXT), originally of type
3085 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
3089 option_name (diagnostic_context
*context
, int option_index
,
3090 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
3094 /* A warning classified as an error. */
3095 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
3096 && diag_kind
== DK_ERROR
)
3097 return concat (cl_options
[OPT_Werror_
].opt_text
,
3098 /* Skip over "-W". */
3099 cl_options
[option_index
].opt_text
+ 2,
3101 /* A warning with option. */
3103 return xstrdup (cl_options
[option_index
].opt_text
);
3105 /* A warning without option classified as an error. */
3106 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
3107 || diag_kind
== DK_WARNING
)
3108 && context
->warning_as_error_requested
)
3109 return xstrdup (cl_options
[OPT_Werror
].opt_text
);