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
},
560 /* -Ofast adds optimizations to -O3. */
561 { OPT_LEVELS_FAST
, OPT_ffast_math
, NULL
, 1 },
563 { OPT_LEVELS_NONE
, 0, NULL
, 0 }
566 /* Default the options in OPTS and OPTS_SET based on the optimization
567 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
569 default_options_optimization (struct gcc_options
*opts
,
570 struct gcc_options
*opts_set
,
571 struct cl_decoded_option
*decoded_options
,
572 unsigned int decoded_options_count
,
574 unsigned int lang_mask
,
575 const struct cl_option_handlers
*handlers
,
576 diagnostic_context
*dc
)
580 bool openacc_mode
= false;
582 /* Scan to see what optimization level has been specified. That will
583 determine the default value of many flags. */
584 for (i
= 1; i
< decoded_options_count
; i
++)
586 struct cl_decoded_option
*opt
= &decoded_options
[i
];
587 switch (opt
->opt_index
)
590 if (*opt
->arg
== '\0')
592 opts
->x_optimize
= 1;
593 opts
->x_optimize_size
= 0;
594 opts
->x_optimize_fast
= 0;
595 opts
->x_optimize_debug
= 0;
599 const int optimize_val
= integral_argument (opt
->arg
);
600 if (optimize_val
== -1)
601 error_at (loc
, "argument to %<-O%> should be a non-negative "
602 "integer, %<g%>, %<s%> or %<fast%>");
605 opts
->x_optimize
= optimize_val
;
606 if ((unsigned int) opts
->x_optimize
> 255)
607 opts
->x_optimize
= 255;
608 opts
->x_optimize_size
= 0;
609 opts
->x_optimize_fast
= 0;
610 opts
->x_optimize_debug
= 0;
616 opts
->x_optimize_size
= 1;
618 /* Optimizing for size forces optimize to be 2. */
619 opts
->x_optimize
= 2;
620 opts
->x_optimize_fast
= 0;
621 opts
->x_optimize_debug
= 0;
625 /* -Ofast only adds flags to -O3. */
626 opts
->x_optimize_size
= 0;
627 opts
->x_optimize
= 3;
628 opts
->x_optimize_fast
= 1;
629 opts
->x_optimize_debug
= 0;
633 /* -Og selects optimization level 1. */
634 opts
->x_optimize_size
= 0;
635 opts
->x_optimize
= 1;
636 opts
->x_optimize_fast
= 0;
637 opts
->x_optimize_debug
= 1;
646 /* Ignore other options in this prescan. */
651 maybe_default_options (opts
, opts_set
, default_options_table
,
652 opts
->x_optimize
, opts
->x_optimize_size
,
653 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
654 lang_mask
, handlers
, loc
, dc
);
656 /* -O2 param settings. */
657 opt2
= (opts
->x_optimize
>= 2);
660 && !opts_set
->x_flag_ipa_pta
)
661 opts
->x_flag_ipa_pta
= true;
663 /* Track fields in field-sensitive alias analysis. */
664 maybe_set_param_value
665 (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
,
666 opt2
? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
),
667 opts
->x_param_values
, opts_set
->x_param_values
);
669 /* For -O1 only do loop invariant motion for very small loops. */
670 maybe_set_param_value
671 (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
,
672 opt2
? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
) : 1000,
673 opts
->x_param_values
, opts_set
->x_param_values
);
675 /* At -Ofast, allow store motion to introduce potential race conditions. */
676 maybe_set_param_value
677 (PARAM_ALLOW_STORE_DATA_RACES
,
678 opts
->x_optimize_fast
? 1
679 : default_param_value (PARAM_ALLOW_STORE_DATA_RACES
),
680 opts
->x_param_values
, opts_set
->x_param_values
);
682 if (opts
->x_optimize_size
)
683 /* We want to crossjump as much as possible. */
684 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
, 1,
685 opts
->x_param_values
, opts_set
->x_param_values
);
687 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
,
688 default_param_value (PARAM_MIN_CROSSJUMP_INSNS
),
689 opts
->x_param_values
, opts_set
->x_param_values
);
691 /* Restrict the amount of work combine does at -Og while retaining
692 most of its useful transforms. */
693 if (opts
->x_optimize_debug
)
694 maybe_set_param_value (PARAM_MAX_COMBINE_INSNS
, 2,
695 opts
->x_param_values
, opts_set
->x_param_values
);
697 /* Allow default optimizations to be specified on a per-machine basis. */
698 maybe_default_options (opts
, opts_set
,
699 targetm_common
.option_optimization_table
,
700 opts
->x_optimize
, opts
->x_optimize_size
,
701 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
702 lang_mask
, handlers
, loc
, dc
);
705 /* Control IPA optimizations based on different live patching LEVEL. */
707 control_options_for_live_patching (struct gcc_options
*opts
,
708 struct gcc_options
*opts_set
,
709 enum live_patching_level level
,
712 gcc_assert (level
> LIVE_PATCHING_NONE
);
716 case LIVE_PATCHING_INLINE_ONLY_STATIC
:
717 if (opts_set
->x_flag_ipa_cp_clone
&& opts
->x_flag_ipa_cp_clone
)
719 "%<-fipa-cp-clone%> is incompatible with "
720 "%<-flive-patching=inline-only-static%>");
722 opts
->x_flag_ipa_cp_clone
= 0;
724 if (opts_set
->x_flag_ipa_sra
&& opts
->x_flag_ipa_sra
)
726 "%<-fipa-sra%> is incompatible with "
727 "%<-flive-patching=inline-only-static%>");
729 opts
->x_flag_ipa_sra
= 0;
731 if (opts_set
->x_flag_partial_inlining
&& opts
->x_flag_partial_inlining
)
733 "%<-fpartial-inlining%> is incompatible with "
734 "%<-flive-patching=inline-only-static%>");
736 opts
->x_flag_partial_inlining
= 0;
738 if (opts_set
->x_flag_ipa_cp
&& opts
->x_flag_ipa_cp
)
740 "%<-fipa-cp%> is incompatible with "
741 "%<-flive-patching=inline-only-static%>");
743 opts
->x_flag_ipa_cp
= 0;
746 case LIVE_PATCHING_INLINE_CLONE
:
747 /* live patching should disable whole-program optimization. */
748 if (opts_set
->x_flag_whole_program
&& opts
->x_flag_whole_program
)
750 "%<-fwhole-program%> is incompatible with "
751 "%<-flive-patching=inline-only-static|inline-clone%>");
753 opts
->x_flag_whole_program
= 0;
755 /* visibility change should be excluded by !flag_whole_program
756 && !in_lto_p && !flag_ipa_cp_clone && !flag_ipa_sra
757 && !flag_partial_inlining. */
759 if (opts_set
->x_flag_ipa_pta
&& opts
->x_flag_ipa_pta
)
761 "%<-fipa-pta%> is incompatible with "
762 "%<-flive-patching=inline-only-static|inline-clone%>");
764 opts
->x_flag_ipa_pta
= 0;
766 if (opts_set
->x_flag_ipa_reference
&& opts
->x_flag_ipa_reference
)
768 "%<-fipa-reference%> is incompatible with "
769 "%<-flive-patching=inline-only-static|inline-clone%>");
771 opts
->x_flag_ipa_reference
= 0;
773 if (opts_set
->x_flag_ipa_ra
&& opts
->x_flag_ipa_ra
)
775 "%<-fipa-ra%> is incompatible with "
776 "%<-flive-patching=inline-only-static|inline-clone%>");
778 opts
->x_flag_ipa_ra
= 0;
780 if (opts_set
->x_flag_ipa_icf
&& opts
->x_flag_ipa_icf
)
782 "%<-fipa-icf%> is incompatible with "
783 "%<-flive-patching=inline-only-static|inline-clone%>");
785 opts
->x_flag_ipa_icf
= 0;
787 if (opts_set
->x_flag_ipa_icf_functions
&& opts
->x_flag_ipa_icf_functions
)
789 "%<-fipa-icf-functions%> is incompatible with "
790 "%<-flive-patching=inline-only-static|inline-clone%>");
792 opts
->x_flag_ipa_icf_functions
= 0;
794 if (opts_set
->x_flag_ipa_icf_variables
&& opts
->x_flag_ipa_icf_variables
)
796 "%<-fipa-icf-variables%> is incompatible with "
797 "%<-flive-patching=inline-only-static|inline-clone%>");
799 opts
->x_flag_ipa_icf_variables
= 0;
801 if (opts_set
->x_flag_ipa_bit_cp
&& opts
->x_flag_ipa_bit_cp
)
803 "%<-fipa-bit-cp%> is incompatible with "
804 "%<-flive-patching=inline-only-static|inline-clone%>");
806 opts
->x_flag_ipa_bit_cp
= 0;
808 if (opts_set
->x_flag_ipa_vrp
&& opts
->x_flag_ipa_vrp
)
810 "%<-fipa-vrp%> is incompatible with "
811 "%<-flive-patching=inline-only-static|inline-clone%>");
813 opts
->x_flag_ipa_vrp
= 0;
815 if (opts_set
->x_flag_ipa_pure_const
&& opts
->x_flag_ipa_pure_const
)
817 "%<-fipa-pure-const%> is incompatible with "
818 "%<-flive-patching=inline-only-static|inline-clone%>");
820 opts
->x_flag_ipa_pure_const
= 0;
822 /* FIXME: disable unreachable code removal. */
824 /* discovery of functions/variables with no address taken. */
825 if (opts_set
->x_flag_ipa_reference_addressable
826 && opts
->x_flag_ipa_reference_addressable
)
828 "%<-fipa-reference-addressable%> is incompatible with "
829 "%<-flive-patching=inline-only-static|inline-clone%>");
831 opts
->x_flag_ipa_reference_addressable
= 0;
833 /* ipa stack alignment propagation. */
834 if (opts_set
->x_flag_ipa_stack_alignment
835 && opts
->x_flag_ipa_stack_alignment
)
837 "%<-fipa-stack-alignment%> is incompatible with "
838 "%<-flive-patching=inline-only-static|inline-clone%>");
840 opts
->x_flag_ipa_stack_alignment
= 0;
847 /* After all options at LOC have been read into OPTS and OPTS_SET,
848 finalize settings of those options and diagnose incompatible
851 finish_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
854 enum unwind_info_type ui_except
;
856 if (opts
->x_dump_base_name
857 && ! opts
->x_dump_base_name_prefixed
)
859 const char *sep
= opts
->x_dump_base_name
;
862 if (IS_DIR_SEPARATOR (*sep
))
866 /* If dump_base_path contains subdirectories, don't prepend
868 else if (opts
->x_dump_dir_name
)
869 /* We have a DUMP_DIR_NAME, prepend that. */
870 opts
->x_dump_base_name
= opts_concat (opts
->x_dump_dir_name
,
871 opts
->x_dump_base_name
, NULL
);
872 else if (opts
->x_aux_base_name
873 && strcmp (opts
->x_aux_base_name
, HOST_BIT_BUCKET
) != 0)
874 /* AUX_BASE_NAME is set and is not the bit bucket. If it
875 contains a directory component, prepend those directories.
876 Typically this places things in the same directory as the
879 const char *aux_base
;
881 base_of_path (opts
->x_aux_base_name
, &aux_base
);
882 if (opts
->x_aux_base_name
!= aux_base
)
884 int dir_len
= aux_base
- opts
->x_aux_base_name
;
885 char *new_dump_base_name
886 = XOBNEWVEC (&opts_obstack
, char,
887 strlen (opts
->x_dump_base_name
) + dir_len
+ 1);
889 /* Copy directory component from OPTS->X_AUX_BASE_NAME. */
890 memcpy (new_dump_base_name
, opts
->x_aux_base_name
, dir_len
);
891 /* Append existing OPTS->X_DUMP_BASE_NAME. */
892 strcpy (new_dump_base_name
+ dir_len
, opts
->x_dump_base_name
);
893 opts
->x_dump_base_name
= new_dump_base_name
;
897 /* It is definitely prefixed now. */
898 opts
->x_dump_base_name_prefixed
= true;
901 /* Handle related options for unit-at-a-time, toplevel-reorder, and
903 if (!opts
->x_flag_unit_at_a_time
)
905 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
906 error_at (loc
, "section anchors must be disabled when unit-at-a-time "
908 opts
->x_flag_section_anchors
= 0;
909 if (opts
->x_flag_toplevel_reorder
== 1)
910 error_at (loc
, "toplevel reorder must be disabled when unit-at-a-time "
912 opts
->x_flag_toplevel_reorder
= 0;
915 /* -fself-test depends on the state of the compiler prior to
916 compiling anything. Ideally it should be run on an empty source
917 file. However, in case we get run with actual source, assume
918 -fsyntax-only which will inhibit any compiler initialization
919 which may confuse the self tests. */
920 if (opts
->x_flag_self_test
)
921 opts
->x_flag_syntax_only
= 1;
923 if (opts
->x_flag_tm
&& opts
->x_flag_non_call_exceptions
)
924 sorry ("transactional memory is not supported with non-call exceptions");
926 /* Unless the user has asked for section anchors, we disable toplevel
927 reordering at -O0 to disable transformations that might be surprising
928 to end users and to get -fno-toplevel-reorder tested. */
929 if (!opts
->x_optimize
930 && opts
->x_flag_toplevel_reorder
== 2
931 && !(opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
))
933 opts
->x_flag_toplevel_reorder
= 0;
934 opts
->x_flag_section_anchors
= 0;
936 if (!opts
->x_flag_toplevel_reorder
)
938 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
939 error_at (loc
, "section anchors must be disabled when toplevel reorder"
941 opts
->x_flag_section_anchors
= 0;
944 if (!opts
->x_flag_opts_finished
)
946 /* We initialize opts->x_flag_pie to -1 so that targets can set a
948 if (opts
->x_flag_pie
== -1)
950 /* We initialize opts->x_flag_pic to -1 so that we can tell if
951 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
952 if (opts
->x_flag_pic
== -1)
953 opts
->x_flag_pie
= DEFAULT_FLAG_PIE
;
955 opts
->x_flag_pie
= 0;
957 /* If -fPIE or -fpie is used, turn on PIC. */
958 if (opts
->x_flag_pie
)
959 opts
->x_flag_pic
= opts
->x_flag_pie
;
960 else if (opts
->x_flag_pic
== -1)
961 opts
->x_flag_pic
= 0;
962 if (opts
->x_flag_pic
&& !opts
->x_flag_pie
)
963 opts
->x_flag_shlib
= 1;
964 opts
->x_flag_opts_finished
= true;
967 /* We initialize opts->x_flag_stack_protect to -1 so that targets
968 can set a default value. */
969 if (opts
->x_flag_stack_protect
== -1)
970 opts
->x_flag_stack_protect
= DEFAULT_FLAG_SSP
;
972 if (opts
->x_optimize
== 0)
974 /* Inlining does not work if not optimizing,
975 so force it not to be done. */
976 opts
->x_warn_inline
= 0;
977 opts
->x_flag_no_inline
= 1;
980 /* The optimization to partition hot and cold basic blocks into separate
981 sections of the .o and executable files does not work (currently)
982 with exception handling. This is because there is no support for
983 generating unwind info. If opts->x_flag_exceptions is turned on
984 we need to turn off the partitioning optimization. */
986 ui_except
= targetm_common
.except_unwind_info (opts
);
988 if (opts
->x_flag_exceptions
989 && opts
->x_flag_reorder_blocks_and_partition
990 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
992 if (opts_set
->x_flag_reorder_blocks_and_partition
)
994 "%<-freorder-blocks-and-partition%> does not work "
995 "with exceptions on this architecture");
996 opts
->x_flag_reorder_blocks_and_partition
= 0;
997 opts
->x_flag_reorder_blocks
= 1;
1000 /* If user requested unwind info, then turn off the partitioning
1003 if (opts
->x_flag_unwind_tables
1004 && !targetm_common
.unwind_tables_default
1005 && opts
->x_flag_reorder_blocks_and_partition
1006 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
1008 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1010 "%<-freorder-blocks-and-partition%> does not support "
1011 "unwind info on this architecture");
1012 opts
->x_flag_reorder_blocks_and_partition
= 0;
1013 opts
->x_flag_reorder_blocks
= 1;
1016 /* If the target requested unwind info, then turn off the partitioning
1017 optimization with a different message. Likewise, if the target does not
1018 support named sections. */
1020 if (opts
->x_flag_reorder_blocks_and_partition
1021 && (!targetm_common
.have_named_sections
1022 || (opts
->x_flag_unwind_tables
1023 && targetm_common
.unwind_tables_default
1024 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
1026 if (opts_set
->x_flag_reorder_blocks_and_partition
)
1028 "%<-freorder-blocks-and-partition%> does not work "
1029 "on this architecture");
1030 opts
->x_flag_reorder_blocks_and_partition
= 0;
1031 opts
->x_flag_reorder_blocks
= 1;
1035 /* Pipelining of outer loops is only possible when general pipelining
1036 capabilities are requested. */
1037 if (!opts
->x_flag_sel_sched_pipelining
)
1038 opts
->x_flag_sel_sched_pipelining_outer_loops
= 0;
1040 if (opts
->x_flag_conserve_stack
)
1042 maybe_set_param_value (PARAM_LARGE_STACK_FRAME
, 100,
1043 opts
->x_param_values
, opts_set
->x_param_values
);
1044 maybe_set_param_value (PARAM_STACK_FRAME_GROWTH
, 40,
1045 opts
->x_param_values
, opts_set
->x_param_values
);
1048 if (opts
->x_flag_lto
)
1051 opts
->x_flag_generate_lto
= 1;
1053 /* When generating IL, do not operate in whole-program mode.
1054 Otherwise, symbols will be privatized too early, causing link
1056 opts
->x_flag_whole_program
= 0;
1058 error_at (loc
, "LTO support has not been enabled in this configuration");
1060 if (!opts
->x_flag_fat_lto_objects
1061 && (!HAVE_LTO_PLUGIN
1062 || (opts_set
->x_flag_use_linker_plugin
1063 && !opts
->x_flag_use_linker_plugin
)))
1065 if (opts_set
->x_flag_fat_lto_objects
)
1066 error_at (loc
, "%<-fno-fat-lto-objects%> are supported only with "
1068 opts
->x_flag_fat_lto_objects
= 1;
1072 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
1073 default value if they choose based on other options. */
1074 if (opts
->x_flag_split_stack
== -1)
1075 opts
->x_flag_split_stack
= 0;
1076 else if (opts
->x_flag_split_stack
)
1078 if (!targetm_common
.supports_split_stack (true, opts
))
1080 error_at (loc
, "%<-fsplit-stack%> is not supported by "
1081 "this compiler configuration");
1082 opts
->x_flag_split_stack
= 0;
1086 /* If stack splitting is turned on, and the user did not explicitly
1087 request function partitioning, turn off partitioning, as it
1088 confuses the linker when trying to handle partitioned split-stack
1089 code that calls a non-split-stack functions. But if partitioning
1090 was turned on explicitly just hope for the best. */
1091 if (opts
->x_flag_split_stack
1092 && opts
->x_flag_reorder_blocks_and_partition
1093 && !opts_set
->x_flag_reorder_blocks_and_partition
)
1094 opts
->x_flag_reorder_blocks_and_partition
= 0;
1096 if (opts
->x_flag_reorder_blocks_and_partition
1097 && !opts_set
->x_flag_reorder_functions
)
1098 opts
->x_flag_reorder_functions
= 1;
1100 /* Tune vectorization related parametees according to cost model. */
1101 if (opts
->x_flag_vect_cost_model
== VECT_COST_MODEL_CHEAP
)
1103 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS
,
1104 6, opts
->x_param_values
, opts_set
->x_param_values
);
1105 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS
,
1106 0, opts
->x_param_values
, opts_set
->x_param_values
);
1107 maybe_set_param_value (PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT
,
1108 0, opts
->x_param_values
, opts_set
->x_param_values
);
1111 /* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
1113 if ((!opts
->x_flag_tree_loop_vectorize
&& !opts
->x_flag_tree_slp_vectorize
)
1114 || !opts
->x_flag_tree_loop_if_convert
)
1115 maybe_set_param_value (PARAM_MAX_STORES_TO_SINK
, 0,
1116 opts
->x_param_values
, opts_set
->x_param_values
);
1118 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
1119 if (opts
->x_dwarf_split_debug_info
)
1120 opts
->x_debug_generate_pub_sections
= 2;
1122 if ((opts
->x_flag_sanitize
1123 & (SANITIZE_USER_ADDRESS
| SANITIZE_KERNEL_ADDRESS
)) == 0)
1125 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_COMPARE
)
1127 "%<-fsanitize=pointer-compare%> must be combined with "
1128 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1129 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_SUBTRACT
)
1131 "%<-fsanitize=pointer-subtract%> must be combined with "
1132 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1135 /* Userspace and kernel ASan conflict with each other. */
1136 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
1137 && (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
))
1139 "%<-fsanitize=address%> is incompatible with "
1140 "%<-fsanitize=kernel-address%>");
1142 /* And with TSan. */
1143 if ((opts
->x_flag_sanitize
& SANITIZE_ADDRESS
)
1144 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
1146 "%<-fsanitize=address%> and %<-fsanitize=kernel-address%> "
1147 "are incompatible with %<-fsanitize=thread%>");
1149 if ((opts
->x_flag_sanitize
& SANITIZE_LEAK
)
1150 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
1152 "%<-fsanitize=leak%> is incompatible with %<-fsanitize=thread%>");
1154 /* Check error recovery for -fsanitize-recover option. */
1155 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1156 if ((opts
->x_flag_sanitize_recover
& sanitizer_opts
[i
].flag
)
1157 && !sanitizer_opts
[i
].can_recover
)
1158 error_at (loc
, "%<-fsanitize-recover=%s%> is not supported",
1159 sanitizer_opts
[i
].name
);
1161 /* When instrumenting the pointers, we don't want to remove
1162 the null pointer checks. */
1163 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
1164 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
1165 opts
->x_flag_delete_null_pointer_checks
= 0;
1167 /* Aggressive compiler optimizations may cause false negatives. */
1168 if (opts
->x_flag_sanitize
& ~(SANITIZE_LEAK
| SANITIZE_UNREACHABLE
))
1169 opts
->x_flag_aggressive_loop_optimizations
= 0;
1171 /* Enable -fsanitize-address-use-after-scope if address sanitizer is
1173 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
1174 && !opts_set
->x_flag_sanitize_address_use_after_scope
)
1175 opts
->x_flag_sanitize_address_use_after_scope
= true;
1177 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1179 if (opts
->x_flag_sanitize_address_use_after_scope
)
1181 if (opts
->x_flag_stack_reuse
!= SR_NONE
1182 && opts_set
->x_flag_stack_reuse
!= SR_NONE
)
1184 "%<-fsanitize-address-use-after-scope%> requires "
1185 "%<-fstack-reuse=none%> option");
1187 opts
->x_flag_stack_reuse
= SR_NONE
;
1190 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
) && opts
->x_flag_tm
)
1191 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1193 if ((opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) && opts
->x_flag_tm
)
1194 sorry ("transactional memory is not supported with "
1195 "%<-fsanitize=kernel-address%>");
1197 /* Currently live patching is not support for LTO. */
1198 if (opts
->x_flag_live_patching
&& opts
->x_flag_lto
)
1199 sorry ("live patching is not supported with LTO");
1201 /* Control IPA optimizations based on different -flive-patching level. */
1202 if (opts
->x_flag_live_patching
)
1204 control_options_for_live_patching (opts
, opts_set
,
1205 opts
->x_flag_live_patching
,
1210 #define LEFT_COLUMN 27
1212 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1213 followed by word-wrapped HELP in a second column. */
1215 wrap_help (const char *help
,
1217 unsigned int item_width
,
1218 unsigned int columns
)
1220 unsigned int col_width
= LEFT_COLUMN
;
1221 unsigned int remaining
, room
, len
;
1223 remaining
= strlen (help
);
1227 room
= columns
- 3 - MAX (col_width
, item_width
);
1236 for (i
= 0; help
[i
]; i
++)
1238 if (i
>= room
&& len
!= remaining
)
1242 else if ((help
[i
] == '-' || help
[i
] == '/')
1243 && help
[i
+ 1] != ' '
1244 && i
> 0 && ISALPHA (help
[i
- 1]))
1249 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1251 while (help
[len
] == ' ')
1259 /* Data structure used to print list of valid option values. */
1261 struct option_help_tuple
1263 option_help_tuple (int code
, vec
<const char *> values
):
1264 m_code (code
), m_values (values
)
1267 /* Code of an option. */
1270 /* List of possible values. */
1271 vec
<const char *> m_values
;
1274 /* Print help for a specific front-end, etc. */
1276 print_filtered_help (unsigned int include_flags
,
1277 unsigned int exclude_flags
,
1278 unsigned int any_flags
,
1279 unsigned int columns
,
1280 struct gcc_options
*opts
,
1281 unsigned int lang_mask
)
1286 bool displayed
= false;
1289 if (include_flags
== CL_PARAMS
)
1291 for (i
= 0; i
< LAST_PARAM
; i
++)
1293 const char *param
= compiler_params
[i
].option
;
1295 help
= compiler_params
[i
].help
;
1296 if (help
== NULL
|| *help
== '\0')
1298 if (exclude_flags
& CL_UNDOCUMENTED
)
1300 help
= undocumented_msg
;
1303 /* Get the translation. */
1306 if (!opts
->x_quiet_flag
)
1308 snprintf (new_help
, sizeof (new_help
),
1309 _("default %d minimum %d maximum %d"),
1310 compiler_params
[i
].default_value
,
1311 compiler_params
[i
].min_value
,
1312 compiler_params
[i
].max_value
);
1315 wrap_help (help
, param
, strlen (param
), columns
);
1321 if (!opts
->x_help_printed
)
1322 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1324 if (!opts
->x_help_enum_printed
)
1325 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1327 auto_vec
<option_help_tuple
> help_tuples
;
1329 for (i
= 0; i
< cl_options_count
; i
++)
1331 const struct cl_option
*option
= cl_options
+ i
;
1336 if (include_flags
== 0
1337 || ((option
->flags
& include_flags
) != include_flags
))
1339 if ((option
->flags
& any_flags
) == 0)
1343 /* Skip unwanted switches. */
1344 if ((option
->flags
& exclude_flags
) != 0)
1347 /* The driver currently prints its own help text. */
1348 if ((option
->flags
& CL_DRIVER
) != 0
1349 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1350 | CL_COMMON
| CL_TARGET
)) == 0)
1354 /* Skip switches that have already been printed. */
1355 if (opts
->x_help_printed
[i
])
1358 opts
->x_help_printed
[i
] = true;
1360 help
= option
->help
;
1363 if (exclude_flags
& CL_UNDOCUMENTED
)
1366 help
= undocumented_msg
;
1369 if (option
->alias_target
< N_OPTS
1370 && cl_options
[option
->alias_target
].help
)
1372 if (help
== undocumented_msg
)
1374 /* For undocumented options that are aliases for other options
1375 that are documented, point the reader to the other option in
1376 preference of the former. */
1377 snprintf (new_help
, sizeof new_help
,
1378 _("Same as %s. Use the latter option instead."),
1379 cl_options
[option
->alias_target
].opt_text
);
1383 /* For documented options with aliases, mention the aliased
1384 option's name for reference. */
1385 snprintf (new_help
, sizeof new_help
,
1386 _("%s Same as %s."),
1387 help
, cl_options
[option
->alias_target
].opt_text
);
1393 if (option
->warn_message
)
1395 /* Mention that the use of the option will trigger a warning. */
1396 if (help
== new_help
)
1397 snprintf (new_help
+ strlen (new_help
),
1398 sizeof new_help
- strlen (new_help
),
1399 " %s", _(use_diagnosed_msg
));
1401 snprintf (new_help
, sizeof new_help
,
1402 "%s %s", help
, _(use_diagnosed_msg
));
1407 /* Get the translation. */
1410 /* Find the gap between the name of the
1411 option and its descriptive text. */
1412 tab
= strchr (help
, '\t');
1421 opt
= option
->opt_text
;
1425 /* With the -Q option enabled we change the descriptive text associated
1426 with an option to be an indication of its current setting. */
1427 if (!opts
->x_quiet_flag
)
1429 void *flag_var
= option_flag_var (i
, opts
);
1431 if (len
< (LEFT_COLUMN
+ 2))
1432 strcpy (new_help
, "\t\t");
1434 strcpy (new_help
, "\t");
1436 if (flag_var
!= NULL
1437 && option
->var_type
!= CLVC_DEFER
)
1439 if (option
->flags
& CL_JOINED
)
1441 if (option
->var_type
== CLVC_STRING
)
1443 if (* (const char **) flag_var
!= NULL
)
1444 snprintf (new_help
+ strlen (new_help
),
1445 sizeof (new_help
) - strlen (new_help
),
1446 "%s", * (const char **) flag_var
);
1448 else if (option
->var_type
== CLVC_ENUM
)
1450 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1452 const char *arg
= NULL
;
1454 value
= e
->get (flag_var
);
1455 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1457 arg
= _("[default]");
1458 snprintf (new_help
+ strlen (new_help
),
1459 sizeof (new_help
) - strlen (new_help
),
1463 sprintf (new_help
+ strlen (new_help
),
1464 "%d", * (int *) flag_var
);
1467 strcat (new_help
, option_enabled (i
, opts
)
1468 ? _("[enabled]") : _("[disabled]"));
1474 if (option
->range_max
!= -1)
1477 snprintf (b
, sizeof (b
), "<%d,%d>", option
->range_min
,
1479 opt
= concat (opt
, b
, NULL
);
1483 wrap_help (help
, opt
, len
, columns
);
1486 if (option
->var_type
== CLVC_ENUM
1487 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1488 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1491 vec
<const char *> option_values
1492 = targetm_common
.get_valid_option_values (i
, NULL
);
1493 if (!option_values
.is_empty ())
1494 help_tuples
.safe_push (option_help_tuple (i
, option_values
));
1500 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1503 printf (_(" No options with the desired characteristics were found\n"));
1508 /* PR 31349: Tell the user how to see all of the
1509 options supported by a specific front end. */
1510 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1511 if ((1U << i
) & langs
)
1512 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1513 lang_names
[i
], lang_names
[i
]);
1517 else if (! displayed
)
1518 printf (_(" All options with the desired characteristics have already been displayed\n"));
1522 /* Print details of enumerated option arguments, if those
1523 enumerations have help text headings provided. If no help text
1524 is provided, presume that the possible values are listed in the
1525 help text for the relevant options. */
1526 for (i
= 0; i
< cl_enums_count
; i
++)
1528 unsigned int j
, pos
;
1530 if (opts
->x_help_enum_printed
[i
] != 1)
1532 if (cl_enums
[i
].help
== NULL
)
1534 printf (" %s\n ", _(cl_enums
[i
].help
));
1536 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1538 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1540 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1542 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1552 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1557 opts
->x_help_enum_printed
[i
] = 2;
1560 for (unsigned i
= 0; i
< help_tuples
.length (); i
++)
1562 const struct cl_option
*option
= cl_options
+ help_tuples
[i
].m_code
;
1563 printf (" Known valid arguments for %s option:\n ", option
->opt_text
);
1564 for (unsigned j
= 0; j
< help_tuples
[i
].m_values
.length (); j
++)
1565 printf (" %s", help_tuples
[i
].m_values
[j
]);
1570 /* Display help for a specified type of option.
1571 The options must have ALL of the INCLUDE_FLAGS set
1572 ANY of the flags in the ANY_FLAGS set
1573 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1574 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1576 print_specific_help (unsigned int include_flags
,
1577 unsigned int exclude_flags
,
1578 unsigned int any_flags
,
1579 struct gcc_options
*opts
,
1580 unsigned int lang_mask
)
1582 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1583 const char * description
= NULL
;
1584 const char * descrip_extra
= "";
1588 /* Sanity check: Make sure that we do not have more
1589 languages than we have bits available to enumerate them. */
1590 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1592 /* If we have not done so already, obtain
1593 the desired maximum width of the output. */
1594 if (opts
->x_help_columns
== 0)
1596 opts
->x_help_columns
= get_terminal_width ();
1597 if (opts
->x_help_columns
== INT_MAX
)
1598 /* Use a reasonable default. */
1599 opts
->x_help_columns
= 80;
1602 /* Decide upon the title for the options that we are going to display. */
1603 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1605 switch (flag
& include_flags
)
1612 description
= _("The following options are target specific");
1615 description
= _("The following options control compiler warning messages");
1617 case CL_OPTIMIZATION
:
1618 description
= _("The following options control optimizations");
1621 description
= _("The following options are language-independent");
1624 description
= _("The --param option recognizes the following as parameters");
1627 if (i
>= cl_lang_count
)
1629 if (exclude_flags
& all_langs_mask
)
1630 description
= _("The following options are specific to just the language ");
1632 description
= _("The following options are supported by the language ");
1633 descrip_extra
= lang_names
[i
];
1638 if (description
== NULL
)
1642 if (include_flags
& CL_UNDOCUMENTED
)
1643 description
= _("The following options are not documented");
1644 else if (include_flags
& CL_SEPARATE
)
1645 description
= _("The following options take separate arguments");
1646 else if (include_flags
& CL_JOINED
)
1647 description
= _("The following options take joined arguments");
1650 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1657 if (any_flags
& all_langs_mask
)
1658 description
= _("The following options are language-related");
1660 description
= _("The following options are language-independent");
1664 printf ("%s%s:\n", description
, descrip_extra
);
1665 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
1666 opts
->x_help_columns
, opts
, lang_mask
);
1669 /* Enable FDO-related flags. */
1672 enable_fdo_optimizations (struct gcc_options
*opts
,
1673 struct gcc_options
*opts_set
,
1676 if (!opts_set
->x_flag_branch_probabilities
)
1677 opts
->x_flag_branch_probabilities
= value
;
1678 if (!opts_set
->x_flag_profile_values
)
1679 opts
->x_flag_profile_values
= value
;
1680 if (!opts_set
->x_flag_unroll_loops
)
1681 opts
->x_flag_unroll_loops
= value
;
1682 if (!opts_set
->x_flag_peel_loops
)
1683 opts
->x_flag_peel_loops
= value
;
1684 if (!opts_set
->x_flag_tracer
)
1685 opts
->x_flag_tracer
= value
;
1686 if (!opts_set
->x_flag_value_profile_transformations
)
1687 opts
->x_flag_value_profile_transformations
= value
;
1688 if (!opts_set
->x_flag_inline_functions
)
1689 opts
->x_flag_inline_functions
= value
;
1690 if (!opts_set
->x_flag_ipa_cp
)
1691 opts
->x_flag_ipa_cp
= value
;
1692 if (!opts_set
->x_flag_ipa_cp_clone
1693 && value
&& opts
->x_flag_ipa_cp
)
1694 opts
->x_flag_ipa_cp_clone
= value
;
1695 if (!opts_set
->x_flag_ipa_bit_cp
1696 && value
&& opts
->x_flag_ipa_cp
)
1697 opts
->x_flag_ipa_bit_cp
= value
;
1698 if (!opts_set
->x_flag_predictive_commoning
)
1699 opts
->x_flag_predictive_commoning
= value
;
1700 if (!opts_set
->x_flag_split_loops
)
1701 opts
->x_flag_split_loops
= value
;
1702 if (!opts_set
->x_flag_unswitch_loops
)
1703 opts
->x_flag_unswitch_loops
= value
;
1704 if (!opts_set
->x_flag_gcse_after_reload
)
1705 opts
->x_flag_gcse_after_reload
= value
;
1706 if (!opts_set
->x_flag_tree_loop_vectorize
)
1707 opts
->x_flag_tree_loop_vectorize
= value
;
1708 if (!opts_set
->x_flag_tree_slp_vectorize
)
1709 opts
->x_flag_tree_slp_vectorize
= value
;
1710 if (!opts_set
->x_flag_vect_cost_model
)
1711 opts
->x_flag_vect_cost_model
= VECT_COST_MODEL_DYNAMIC
;
1712 if (!opts_set
->x_flag_tree_loop_distribute_patterns
)
1713 opts
->x_flag_tree_loop_distribute_patterns
= value
;
1716 /* -f{,no-}sanitize{,-recover}= suboptions. */
1717 const struct sanitizer_opts_s sanitizer_opts
[] =
1719 #define SANITIZER_OPT(name, flags, recover) \
1720 { #name, flags, sizeof #name - 1, recover }
1721 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true),
1722 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
1724 SANITIZER_OPT (pointer
-compare
, SANITIZE_POINTER_COMPARE
, true),
1725 SANITIZER_OPT (pointer
-subtract
, SANITIZE_POINTER_SUBTRACT
, true),
1726 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false),
1727 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false),
1728 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true),
1729 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true),
1730 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true),
1731 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true),
1732 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true),
1733 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false),
1734 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true),
1735 SANITIZER_OPT (return, SANITIZE_RETURN
, false),
1736 SANITIZER_OPT (null
, SANITIZE_NULL
, true),
1737 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true),
1738 SANITIZER_OPT (bool, SANITIZE_BOOL
, true),
1739 SANITIZER_OPT (enum, SANITIZE_ENUM
, true),
1740 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true),
1741 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true),
1742 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true),
1743 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true),
1744 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true),
1745 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true),
1746 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
1748 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true),
1749 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true),
1750 SANITIZER_OPT (pointer
-overflow
, SANITIZE_POINTER_OVERFLOW
, true),
1751 SANITIZER_OPT (builtin
, SANITIZE_BUILTIN
, true),
1752 SANITIZER_OPT (all
, ~0U, true),
1753 #undef SANITIZER_OPT
1754 { NULL
, 0U, 0UL, false }
1757 /* -f{,no-}sanitize-coverage= suboptions. */
1758 const struct sanitizer_opts_s coverage_sanitizer_opts
[] =
1760 #define COVERAGE_SANITIZER_OPT(name, flags) \
1761 { #name, flags, sizeof #name - 1, true }
1762 COVERAGE_SANITIZER_OPT (trace
-pc
, SANITIZE_COV_TRACE_PC
),
1763 COVERAGE_SANITIZER_OPT (trace
-cmp
, SANITIZE_COV_TRACE_CMP
),
1764 #undef COVERAGE_SANITIZER_OPT
1765 { NULL
, 0U, 0UL, false }
1768 /* A struct for describing a run of chars within a string. */
1770 struct string_fragment
1772 string_fragment (const char *start
, size_t len
)
1773 : m_start (start
), m_len (len
) {}
1775 const char *m_start
;
1779 /* Specialization of edit_distance_traits for string_fragment,
1780 for use by get_closest_sanitizer_option. */
1783 struct edit_distance_traits
<const string_fragment
&>
1785 static size_t get_length (const string_fragment
&fragment
)
1787 return fragment
.m_len
;
1790 static const char *get_string (const string_fragment
&fragment
)
1792 return fragment
.m_start
;
1796 /* Given ARG, an unrecognized sanitizer option, return the best
1797 matching sanitizer option, or NULL if there isn't one.
1798 OPTS is array of candidate sanitizer options.
1799 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or
1800 OPT_fsanitize_coverage_.
1801 VALUE is non-zero for the regular form of the option, zero
1802 for the "no-" form (e.g. "-fno-sanitize-recover="). */
1805 get_closest_sanitizer_option (const string_fragment
&arg
,
1806 const struct sanitizer_opts_s
*opts
,
1807 enum opt_code code
, int value
)
1809 best_match
<const string_fragment
&, const char*> bm (arg
);
1810 for (int i
= 0; opts
[i
].name
!= NULL
; ++i
)
1812 /* -fsanitize=all is not valid, so don't offer it. */
1813 if (code
== OPT_fsanitize_
1814 && opts
[i
].flag
== ~0U
1818 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
1819 don't offer the non-recoverable options. */
1820 if (code
== OPT_fsanitize_recover_
1821 && !opts
[i
].can_recover
1825 bm
.consider (opts
[i
].name
);
1827 return bm
.get_best_meaningful_candidate ();
1830 /* Parse comma separated sanitizer suboptions from P for option SCODE,
1831 adjust previous FLAGS and return new ones. If COMPLAIN is false,
1832 don't issue diagnostics. */
1835 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
1836 unsigned int flags
, int value
, bool complain
)
1838 enum opt_code code
= (enum opt_code
) scode
;
1840 const struct sanitizer_opts_s
*opts
;
1841 if (code
== OPT_fsanitize_coverage_
)
1842 opts
= coverage_sanitizer_opts
;
1844 opts
= sanitizer_opts
;
1850 const char *comma
= strchr (p
, ',');
1862 /* Check to see if the string matches an option class name. */
1863 for (i
= 0; opts
[i
].name
!= NULL
; ++i
)
1864 if (len
== opts
[i
].len
&& memcmp (p
, opts
[i
].name
, len
) == 0)
1866 /* Handle both -fsanitize and -fno-sanitize cases. */
1867 if (value
&& opts
[i
].flag
== ~0U)
1869 if (code
== OPT_fsanitize_
)
1872 error_at (loc
, "%<-fsanitize=all%> option is not valid");
1875 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
1876 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
1880 /* Do not enable -fsanitize-recover=unreachable and
1881 -fsanitize-recover=return if -fsanitize-recover=undefined
1883 if (code
== OPT_fsanitize_recover_
1884 && opts
[i
].flag
== SANITIZE_UNDEFINED
)
1885 flags
|= (SANITIZE_UNDEFINED
1886 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
1888 flags
|= opts
[i
].flag
;
1891 flags
&= ~opts
[i
].flag
;
1896 if (! found
&& complain
)
1899 = get_closest_sanitizer_option (string_fragment (p
, len
),
1903 if (code
== OPT_fsanitize_recover_
)
1904 suffix
= "-recover";
1905 else if (code
== OPT_fsanitize_coverage_
)
1906 suffix
= "-coverage";
1912 "unrecognized argument to -f%ssanitize%s= option: %q.*s;"
1913 " did you mean %qs?",
1915 suffix
, (int) len
, p
, hint
);
1918 "unrecognized argument to -f%ssanitize%s= option: %q.*s",
1920 suffix
, (int) len
, p
);
1930 /* Parse string values of no_sanitize attribute passed in VALUE.
1931 Values are separated with comma. */
1934 parse_no_sanitize_attribute (char *value
)
1936 unsigned int flags
= 0;
1938 char *q
= strtok (value
, ",");
1942 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1943 if (strcmp (sanitizer_opts
[i
].name
, q
) == 0)
1945 flags
|= sanitizer_opts
[i
].flag
;
1946 if (sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
1947 flags
|= SANITIZE_UNDEFINED_NONDEFAULT
;
1951 if (sanitizer_opts
[i
].name
== NULL
)
1952 warning (OPT_Wattributes
,
1953 "%<%s%> attribute directive ignored", q
);
1955 q
= strtok (NULL
, ",");
1961 /* Parse -falign-NAME format for a FLAG value. Return individual
1962 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
1963 set, print error message at LOC location. */
1966 parse_and_check_align_values (const char *flag
,
1968 auto_vec
<unsigned> &result_values
,
1972 char *str
= xstrdup (flag
);
1973 for (char *p
= strtok (str
, ":"); p
; p
= strtok (NULL
, ":"))
1976 int v
= strtol (p
, &end
, 10);
1977 if (*end
!= '\0' || v
< 0)
1980 error_at (loc
, "invalid arguments for %<-falign-%s%> option: %qs",
1986 result_values
.safe_push ((unsigned)v
);
1991 /* Check that we have a correct number of values. */
1993 unsigned max_valid_values
= 4;
1995 unsigned max_valid_values
= 2;
1998 if (result_values
.is_empty ()
1999 || result_values
.length () > max_valid_values
)
2002 error_at (loc
, "invalid number of arguments for %<-falign-%s%> "
2003 "option: %qs", name
, flag
);
2007 for (unsigned i
= 0; i
< result_values
.length (); i
++)
2008 if (result_values
[i
] > MAX_CODE_ALIGN_VALUE
)
2011 error_at (loc
, "%<-falign-%s%> is not between 0 and %d",
2012 name
, MAX_CODE_ALIGN_VALUE
);
2019 /* Check that alignment value FLAG for -falign-NAME is valid at a given
2023 check_alignment_argument (location_t loc
, const char *flag
, const char *name
)
2025 auto_vec
<unsigned> align_result
;
2026 parse_and_check_align_values (flag
, name
, align_result
, true, loc
);
2029 /* Handle target- and language-independent options. Return zero to
2030 generate an "unknown option" message. Only options that need
2031 extra handling need to be listed here; if you simply want
2032 DECODED->value assigned to a variable, it happens automatically. */
2035 common_handle_option (struct gcc_options
*opts
,
2036 struct gcc_options
*opts_set
,
2037 const struct cl_decoded_option
*decoded
,
2038 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
2040 const struct cl_option_handlers
*handlers
,
2041 diagnostic_context
*dc
,
2042 void (*target_option_override_hook
) (void))
2044 size_t scode
= decoded
->opt_index
;
2045 const char *arg
= decoded
->arg
;
2046 HOST_WIDE_INT value
= decoded
->value
;
2047 enum opt_code code
= (enum opt_code
) scode
;
2049 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
2054 handle_param (opts
, opts_set
, loc
, arg
);
2059 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
2060 unsigned int undoc_mask
;
2063 if (lang_mask
== CL_DRIVER
)
2066 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
2069 target_option_override_hook ();
2070 /* First display any single language specific options. */
2071 for (i
= 0; i
< cl_lang_count
; i
++)
2073 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
2075 /* Next display any multi language specific options. */
2076 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
2077 /* Then display any remaining, non-language options. */
2078 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
2080 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
2081 opts
->x_exit_after_options
= true;
2085 case OPT__target_help
:
2086 if (lang_mask
== CL_DRIVER
)
2089 target_option_override_hook ();
2090 print_specific_help (CL_TARGET
, CL_UNDOCUMENTED
, 0, opts
, lang_mask
);
2091 opts
->x_exit_after_options
= true;
2096 const char *a
= arg
;
2097 unsigned int include_flags
= 0;
2098 /* Note - by default we include undocumented options when listing
2099 specific classes. If you only want to see documented options
2100 then add ",^undocumented" to the --help= option. E.g.:
2102 --help=target,^undocumented */
2103 unsigned int exclude_flags
= 0;
2105 if (lang_mask
== CL_DRIVER
)
2108 /* Walk along the argument string, parsing each word in turn.
2110 arg = [^]{word}[,{arg}]
2111 word = {optimizers|target|warnings|undocumented|
2112 params|common|<language>} */
2122 { "optimizers", CL_OPTIMIZATION
},
2123 { "target", CL_TARGET
},
2124 { "warnings", CL_WARNING
},
2125 { "undocumented", CL_UNDOCUMENTED
},
2126 { "params", CL_PARAMS
},
2127 { "joined", CL_JOINED
},
2128 { "separate", CL_SEPARATE
},
2129 { "common", CL_COMMON
},
2132 unsigned int *pflags
;
2134 unsigned int lang_flag
, specific_flag
;
2143 error_at (loc
, "missing argument to %qs", "--help=^");
2146 pflags
= &exclude_flags
;
2149 pflags
= &include_flags
;
2151 comma
= strchr (a
, ',');
2162 /* Check to see if the string matches an option class name. */
2163 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
2164 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
2166 specific_flag
= specifics
[i
].flag
;
2170 /* Check to see if the string matches a language name.
2171 Note - we rely upon the alpha-sorted nature of the entries in
2172 the lang_names array, specifically that shorter names appear
2173 before their longer variants. (i.e. C before C++). That way
2174 when we are attempting to match --help=c for example we will
2175 match with C first and not C++. */
2176 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
2177 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
2179 lang_flag
= 1U << i
;
2183 if (specific_flag
!= 0)
2186 *pflags
|= specific_flag
;
2189 /* The option's argument matches both the start of a
2190 language name and the start of an option class name.
2191 We have a special case for when the user has
2192 specified "--help=c", but otherwise we have to issue
2194 if (strncasecmp (a
, "c", len
) == 0)
2195 *pflags
|= lang_flag
;
2198 "--help argument %q.*s is ambiguous, "
2199 "please be more specific",
2203 else if (lang_flag
!= 0)
2204 *pflags
|= lang_flag
;
2207 "unrecognized argument to --help= option: %q.*s",
2217 target_option_override_hook ();
2218 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
2221 opts
->x_exit_after_options
= true;
2226 if (lang_mask
== CL_DRIVER
)
2229 opts
->x_exit_after_options
= true;
2232 case OPT__completion_
:
2235 case OPT_fsanitize_
:
2236 opts
->x_flag_sanitize
2237 = parse_sanitizer_options (arg
, loc
, code
,
2238 opts
->x_flag_sanitize
, value
, true);
2240 /* Kernel ASan implies normal ASan but does not yet support
2242 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
2244 maybe_set_param_value (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD
,
2245 0, opts
->x_param_values
,
2246 opts_set
->x_param_values
);
2247 maybe_set_param_value (PARAM_ASAN_GLOBALS
, 0, opts
->x_param_values
,
2248 opts_set
->x_param_values
);
2249 maybe_set_param_value (PARAM_ASAN_STACK
, 0, opts
->x_param_values
,
2250 opts_set
->x_param_values
);
2251 maybe_set_param_value (PARAM_ASAN_PROTECT_ALLOCAS
, 0,
2252 opts
->x_param_values
,
2253 opts_set
->x_param_values
);
2254 maybe_set_param_value (PARAM_ASAN_USE_AFTER_RETURN
, 0,
2255 opts
->x_param_values
,
2256 opts_set
->x_param_values
);
2260 case OPT_fsanitize_recover_
:
2261 opts
->x_flag_sanitize_recover
2262 = parse_sanitizer_options (arg
, loc
, code
,
2263 opts
->x_flag_sanitize_recover
, value
, true);
2266 case OPT_fasan_shadow_offset_
:
2270 case OPT_fsanitize_address_use_after_scope
:
2271 opts
->x_flag_sanitize_address_use_after_scope
= value
;
2274 case OPT_fsanitize_recover
:
2276 opts
->x_flag_sanitize_recover
2277 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)
2278 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2280 opts
->x_flag_sanitize_recover
2281 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2284 case OPT_fsanitize_coverage_
:
2285 opts
->x_flag_sanitize_coverage
2286 = parse_sanitizer_options (arg
, loc
, code
,
2287 opts
->x_flag_sanitize_coverage
, value
, true);
2294 /* Currently handled in a prescan. */
2298 dc
->warning_as_error_requested
= value
;
2302 if (lang_mask
== CL_DRIVER
)
2305 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
2306 opts
, opts_set
, loc
, dc
);
2309 case OPT_Wfatal_errors
:
2310 dc
->fatal_errors
= value
;
2313 case OPT_Wstack_usage_
:
2314 opts
->x_flag_stack_usage_info
= value
!= -1;
2317 case OPT_Wstrict_aliasing
:
2318 set_Wstrict_aliasing (opts
, value
);
2321 case OPT_Wstrict_overflow
:
2322 opts
->x_warn_strict_overflow
= (value
2323 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2327 case OPT_Wsystem_headers
:
2328 dc
->dc_warn_system_headers
= value
;
2332 opts
->x_flag_gen_aux_info
= 1;
2335 case OPT_auxbase_strip
:
2337 char *tmp
= xstrdup (arg
);
2338 strip_off_ending (tmp
, strlen (tmp
));
2340 opts
->x_aux_base_name
= tmp
;
2347 decode_d_option (arg
, opts
, loc
, dc
);
2350 case OPT_fcall_used_
:
2351 case OPT_fcall_saved_
:
2359 case OPT_fdbg_cnt_list
:
2361 opts
->x_exit_after_options
= true;
2364 case OPT_fdebug_prefix_map_
:
2365 case OPT_ffile_prefix_map_
:
2369 case OPT_fdiagnostics_show_location_
:
2370 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2373 case OPT_fdiagnostics_show_caret
:
2374 dc
->show_caret
= value
;
2377 case OPT_fdiagnostics_show_labels
:
2378 dc
->show_labels_p
= value
;
2381 case OPT_fdiagnostics_show_line_numbers
:
2382 dc
->show_line_numbers_p
= value
;
2385 case OPT_fdiagnostics_color_
:
2386 diagnostic_color_init (dc
, value
);
2389 case OPT_fdiagnostics_format_
:
2390 diagnostic_output_format_init (dc
,
2391 (enum diagnostics_output_format
)value
);
2394 case OPT_fdiagnostics_parseable_fixits
:
2395 dc
->parseable_fixits_p
= value
;
2398 case OPT_fdiagnostics_show_option
:
2399 dc
->show_option_requested
= value
;
2402 case OPT_fdiagnostics_minimum_margin_width_
:
2403 dc
->min_margin_width
= value
;
2410 case OPT_ffast_math
:
2411 set_fast_math_flags (opts
, value
);
2414 case OPT_funsafe_math_optimizations
:
2415 set_unsafe_math_optimizations_flags (opts
, value
);
2422 case OPT_finline_limit_
:
2423 set_param_value ("max-inline-insns-single", value
/ 2,
2424 opts
->x_param_values
, opts_set
->x_param_values
);
2425 set_param_value ("max-inline-insns-auto", value
/ 2,
2426 opts
->x_param_values
, opts_set
->x_param_values
);
2429 case OPT_finstrument_functions_exclude_function_list_
:
2430 add_comma_separated_to_vector
2431 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2434 case OPT_finstrument_functions_exclude_file_list_
:
2435 add_comma_separated_to_vector
2436 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2439 case OPT_fmessage_length_
:
2440 pp_set_line_maximum_length (dc
->printer
, value
);
2441 diagnostic_set_caret_max_width (dc
, value
);
2445 case OPT_fopt_info_
:
2451 const char *p
= arg
;
2452 opts
->x_flag_disable_hsa
= true;
2455 const char *comma
= strchr (p
, ',');
2457 if ((strncmp (p
, "disable", 7) == 0)
2458 && (p
[7] == ',' || p
[7] == '\0'))
2460 opts
->x_flag_disable_hsa
= true;
2464 if ((strncmp (p
, "hsa", 3) == 0)
2465 && (p
[3] == ',' || p
[3] == '\0'))
2468 opts
->x_flag_disable_hsa
= false;
2470 sorry ("HSA has not been enabled during configuration");
2480 #ifndef ACCEL_COMPILER
2481 case OPT_foffload_abi_
:
2482 error_at (loc
, "%<-foffload-abi%> option can be specified only for "
2483 "offload compiler");
2487 case OPT_fpack_struct_
:
2488 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2490 "structure alignment must be a small power of two, not %wu",
2493 opts
->x_initial_max_fld_align
= value
;
2497 case OPT_fplugin_arg_
:
2501 case OPT_fprofile_use_
:
2502 opts
->x_profile_data_prefix
= xstrdup (arg
);
2503 opts
->x_flag_profile_use
= true;
2505 /* No break here - do -fprofile-use processing. */
2507 case OPT_fprofile_use
:
2508 enable_fdo_optimizations (opts
, opts_set
, value
);
2509 if (!opts_set
->x_flag_profile_reorder_functions
)
2510 opts
->x_flag_profile_reorder_functions
= value
;
2511 /* Indirect call profiling should do all useful transformations
2512 speculative devirtualization does. */
2513 if (!opts_set
->x_flag_devirtualize_speculatively
2514 && opts
->x_flag_value_profile_transformations
)
2515 opts
->x_flag_devirtualize_speculatively
= false;
2518 case OPT_fauto_profile_
:
2519 opts
->x_auto_profile_file
= xstrdup (arg
);
2520 opts
->x_flag_auto_profile
= true;
2522 /* No break here - do -fauto-profile processing. */
2524 case OPT_fauto_profile
:
2525 enable_fdo_optimizations (opts
, opts_set
, value
);
2526 if (!opts_set
->x_flag_profile_correction
)
2527 opts
->x_flag_profile_correction
= value
;
2528 maybe_set_param_value (
2529 PARAM_EARLY_INLINER_MAX_ITERATIONS
, 10,
2530 opts
->x_param_values
, opts_set
->x_param_values
);
2533 case OPT_fprofile_generate_
:
2534 opts
->x_profile_data_prefix
= xstrdup (arg
);
2536 /* No break here - do -fprofile-generate processing. */
2538 case OPT_fprofile_generate
:
2539 if (!opts_set
->x_profile_arc_flag
)
2540 opts
->x_profile_arc_flag
= value
;
2541 if (!opts_set
->x_flag_profile_values
)
2542 opts
->x_flag_profile_values
= value
;
2543 if (!opts_set
->x_flag_inline_functions
)
2544 opts
->x_flag_inline_functions
= value
;
2545 if (!opts_set
->x_flag_ipa_bit_cp
)
2546 opts
->x_flag_ipa_bit_cp
= value
;
2547 /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
2548 quadratic. Disable the pass until better memory representation
2550 if (!opts_set
->x_flag_ipa_reference
)
2551 opts
->x_flag_ipa_reference
= false;
2554 case OPT_fpatchable_function_entry_
:
2556 char *patch_area_arg
= xstrdup (arg
);
2557 char *comma
= strchr (patch_area_arg
, ',');
2561 function_entry_patch_area_size
=
2562 integral_argument (patch_area_arg
);
2563 function_entry_patch_area_start
=
2564 integral_argument (comma
+ 1);
2568 function_entry_patch_area_size
=
2569 integral_argument (patch_area_arg
);
2570 function_entry_patch_area_start
= 0;
2572 if (function_entry_patch_area_size
< 0
2573 || function_entry_patch_area_start
< 0
2574 || function_entry_patch_area_size
2575 < function_entry_patch_area_start
)
2576 error ("invalid arguments for %<-fpatchable_function_entry%>");
2577 free (patch_area_arg
);
2581 case OPT_ftree_vectorize
:
2582 /* Automatically sets -ftree-loop-vectorize and
2583 -ftree-slp-vectorize. Nothing more to do here. */
2585 case OPT_fshow_column
:
2586 dc
->show_column
= value
;
2589 case OPT_frandom_seed
:
2590 /* The real switch is -fno-random-seed. */
2596 case OPT_frandom_seed_
:
2600 case OPT_fsched_verbose_
:
2601 #ifdef INSN_SCHEDULING
2602 /* Handled with Var in common.opt. */
2608 case OPT_fsched_stalled_insns_
:
2609 opts
->x_flag_sched_stalled_insns
= value
;
2610 if (opts
->x_flag_sched_stalled_insns
== 0)
2611 opts
->x_flag_sched_stalled_insns
= -1;
2614 case OPT_fsched_stalled_insns_dep_
:
2615 opts
->x_flag_sched_stalled_insns_dep
= value
;
2618 case OPT_fstack_check_
:
2619 if (!strcmp (arg
, "no"))
2620 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
2621 else if (!strcmp (arg
, "generic"))
2622 /* This is the old stack checking method. */
2623 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2624 ? FULL_BUILTIN_STACK_CHECK
2625 : GENERIC_STACK_CHECK
;
2626 else if (!strcmp (arg
, "specific"))
2627 /* This is the new stack checking method. */
2628 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2629 ? FULL_BUILTIN_STACK_CHECK
2630 : STACK_CHECK_STATIC_BUILTIN
2631 ? STATIC_BUILTIN_STACK_CHECK
2632 : GENERIC_STACK_CHECK
;
2634 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
2637 case OPT_fstack_limit
:
2638 /* The real switch is -fno-stack-limit. */
2644 case OPT_fstack_limit_register_
:
2645 case OPT_fstack_limit_symbol_
:
2649 case OPT_fstack_usage
:
2650 opts
->x_flag_stack_usage
= value
;
2651 opts
->x_flag_stack_usage_info
= value
!= 0;
2655 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
2660 if (arg
&& strlen (arg
) != 0)
2662 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
2663 "use %<-gdwarf-%s%> for DWARF version "
2664 "or %<-gdwarf -g%s%> for debug level", arg
, arg
, arg
);
2668 value
= opts
->x_dwarf_version
;
2672 if (value
< 2 || value
> 5)
2673 error_at (loc
, "dwarf version %wu is not supported", value
);
2675 opts
->x_dwarf_version
= value
;
2676 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
2679 case OPT_gsplit_dwarf
:
2680 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, "", opts
, opts_set
,
2685 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
2690 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
, opts
, opts_set
,
2695 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2700 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
, opts
, opts_set
,
2706 /* Handled completely via specs. */
2709 case OPT_pedantic_errors
:
2710 dc
->pedantic_errors
= 1;
2711 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
2713 handlers
, opts
, opts_set
,
2718 opts
->x_flag_lto
= value
? "" : NULL
;
2722 dc
->dc_inhibit_warnings
= true;
2725 case OPT_fmax_errors_
:
2726 dc
->max_errors
= value
;
2729 case OPT_fuse_ld_bfd
:
2730 case OPT_fuse_ld_gold
:
2731 case OPT_fuse_ld_lld
:
2732 case OPT_fuse_linker_plugin
:
2733 /* No-op. Used by the driver and passed to us because it starts with f.*/
2738 opts
->x_flag_trapv
= 0;
2743 opts
->x_flag_wrapv
= 0;
2746 case OPT_fstrict_overflow
:
2747 opts
->x_flag_wrapv
= !value
;
2748 opts
->x_flag_wrapv_pointer
= !value
;
2750 opts
->x_flag_trapv
= 0;
2754 opts
->x_flag_ipa_icf_functions
= value
;
2755 opts
->x_flag_ipa_icf_variables
= value
;
2758 case OPT_falign_loops_
:
2759 check_alignment_argument (loc
, arg
, "loops");
2762 case OPT_falign_jumps_
:
2763 check_alignment_argument (loc
, arg
, "jumps");
2766 case OPT_falign_labels_
:
2767 check_alignment_argument (loc
, arg
, "labels");
2770 case OPT_falign_functions_
:
2771 check_alignment_argument (loc
, arg
, "functions");
2775 /* If the flag was handled in a standard way, assume the lack of
2776 processing here is intentional. */
2777 gcc_assert (option_flag_var (scode
, opts
));
2781 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
2786 /* Handle --param NAME=VALUE. */
2788 handle_param (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2789 location_t loc
, const char *carg
)
2794 arg
= xstrdup (carg
);
2795 equal
= strchr (arg
, '=');
2797 error_at (loc
, "%s: --param arguments should be of the form NAME=VALUE",
2803 enum compiler_param index
;
2804 if (!find_param (arg
, &index
))
2806 const char *suggestion
= find_param_fuzzy (arg
);
2808 error_at (loc
, "invalid --param name %qs; did you mean %qs?",
2811 error_at (loc
, "invalid --param name %qs", arg
);
2815 if (!param_string_value_p (index
, equal
+ 1, &value
))
2816 value
= integral_argument (equal
+ 1);
2819 error_at (loc
, "invalid --param value %qs", equal
+ 1);
2821 set_param_value (arg
, value
,
2822 opts
->x_param_values
, opts_set
->x_param_values
);
2829 /* Used to set the level of strict aliasing warnings in OPTS,
2830 when no level is specified (i.e., when -Wstrict-aliasing, and not
2831 -Wstrict-aliasing=level was given).
2832 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2833 and 0 otherwise. After calling this function, wstrict_aliasing will be
2834 set to the default value of -Wstrict_aliasing=level, currently 3. */
2836 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
2838 gcc_assert (onoff
== 0 || onoff
== 1);
2840 opts
->x_warn_strict_aliasing
= 3;
2842 opts
->x_warn_strict_aliasing
= 0;
2845 /* The following routines are useful in setting all the flags that
2846 -ffast-math and -fno-fast-math imply. */
2848 set_fast_math_flags (struct gcc_options
*opts
, int set
)
2850 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
2852 opts
->x_flag_unsafe_math_optimizations
= set
;
2853 set_unsafe_math_optimizations_flags (opts
, set
);
2855 if (!opts
->frontend_set_flag_finite_math_only
)
2856 opts
->x_flag_finite_math_only
= set
;
2857 if (!opts
->frontend_set_flag_errno_math
)
2858 opts
->x_flag_errno_math
= !set
;
2861 if (opts
->frontend_set_flag_excess_precision_cmdline
2862 == EXCESS_PRECISION_DEFAULT
)
2863 opts
->x_flag_excess_precision_cmdline
2864 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
2865 if (!opts
->frontend_set_flag_signaling_nans
)
2866 opts
->x_flag_signaling_nans
= 0;
2867 if (!opts
->frontend_set_flag_rounding_math
)
2868 opts
->x_flag_rounding_math
= 0;
2869 if (!opts
->frontend_set_flag_cx_limited_range
)
2870 opts
->x_flag_cx_limited_range
= 1;
2874 /* When -funsafe-math-optimizations is set the following
2875 flags are set as well. */
2877 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
2879 if (!opts
->frontend_set_flag_trapping_math
)
2880 opts
->x_flag_trapping_math
= !set
;
2881 if (!opts
->frontend_set_flag_signed_zeros
)
2882 opts
->x_flag_signed_zeros
= !set
;
2883 if (!opts
->frontend_set_flag_associative_math
)
2884 opts
->x_flag_associative_math
= set
;
2885 if (!opts
->frontend_set_flag_reciprocal_math
)
2886 opts
->x_flag_reciprocal_math
= set
;
2889 /* Return true iff flags in OPTS are set as if -ffast-math. */
2891 fast_math_flags_set_p (const struct gcc_options
*opts
)
2893 return (!opts
->x_flag_trapping_math
2894 && opts
->x_flag_unsafe_math_optimizations
2895 && opts
->x_flag_finite_math_only
2896 && !opts
->x_flag_signed_zeros
2897 && !opts
->x_flag_errno_math
2898 && opts
->x_flag_excess_precision_cmdline
2899 == EXCESS_PRECISION_FAST
);
2902 /* Return true iff flags are set as if -ffast-math but using the flags stored
2903 in the struct cl_optimization structure. */
2905 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
2907 return (!opt
->x_flag_trapping_math
2908 && opt
->x_flag_unsafe_math_optimizations
2909 && opt
->x_flag_finite_math_only
2910 && !opt
->x_flag_signed_zeros
2911 && !opt
->x_flag_errno_math
);
2914 /* Handle a debug output -g switch for options OPTS
2915 (OPTS_SET->x_write_symbols storing whether a debug type was passed
2916 explicitly), location LOC. EXTENDED is true or false to support
2917 extended output (2 is special and means "-ggdb" was given). */
2919 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
,
2920 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2923 opts
->x_use_gnu_debug_info_extensions
= extended
;
2925 if (type
== NO_DEBUG
)
2927 if (opts
->x_write_symbols
== NO_DEBUG
)
2929 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
2933 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
2934 opts
->x_write_symbols
= DWARF2_DEBUG
;
2935 #elif defined DBX_DEBUGGING_INFO
2936 opts
->x_write_symbols
= DBX_DEBUG
;
2940 if (opts
->x_write_symbols
== NO_DEBUG
)
2941 warning_at (loc
, 0, "target system does not support debug output");
2946 /* Does it conflict with an already selected type? */
2947 if (opts_set
->x_write_symbols
!= NO_DEBUG
2948 && opts
->x_write_symbols
!= NO_DEBUG
2949 && type
!= opts
->x_write_symbols
)
2950 error_at (loc
, "debug format %qs conflicts with prior selection",
2951 debug_type_names
[type
]);
2952 opts
->x_write_symbols
= type
;
2953 opts_set
->x_write_symbols
= type
;
2956 /* A debug flag without a level defaults to level 2.
2957 If off or at level 1, set it to level 2, but if already
2958 at level 3, don't lower it. */
2961 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
2962 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
2966 int argval
= integral_argument (arg
);
2968 error_at (loc
, "unrecognized debug output level %qs", arg
);
2969 else if (argval
> 3)
2970 error_at (loc
, "debug output level %qs is too high", arg
);
2972 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
2976 /* Arrange to dump core on error for diagnostic context DC. (The
2977 regular error message is still printed first, except in the case of
2981 setup_core_dumping (diagnostic_context
*dc
)
2984 signal (SIGABRT
, SIG_DFL
);
2986 #if defined(HAVE_SETRLIMIT)
2989 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
2990 fatal_error (input_location
, "getting core file size maximum limit: %m");
2991 rlim
.rlim_cur
= rlim
.rlim_max
;
2992 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
2993 fatal_error (input_location
,
2994 "setting core file size limit to maximum: %m");
2997 diagnostic_abort_on_error (dc
);
3000 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
3001 diagnostic context DC. */
3004 decode_d_option (const char *arg
, struct gcc_options
*opts
,
3005 location_t loc
, diagnostic_context
*dc
)
3013 opts
->x_flag_debug_asm
= 1;
3016 opts
->x_flag_print_asm_name
= 1;
3019 opts
->x_flag_dump_rtl_in_asm
= 1;
3020 opts
->x_flag_print_asm_name
= 1;
3023 opts
->x_rtl_dump_and_exit
= 1;
3025 case 'D': /* These are handled by the preprocessor. */
3032 setup_core_dumping (dc
);
3035 opts
->x_flag_dump_all_passed
= true;
3039 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
3044 /* Enable (or disable if VALUE is 0) a warning option ARG (language
3045 mask LANG_MASK, option handlers HANDLERS) as an error for option
3046 structures OPTS and OPTS_SET, diagnostic context DC (possibly
3047 NULL), location LOC. This is used by -Werror=. */
3050 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
3051 const struct cl_option_handlers
*handlers
,
3052 struct gcc_options
*opts
,
3053 struct gcc_options
*opts_set
,
3054 location_t loc
, diagnostic_context
*dc
)
3059 new_option
= XNEWVEC (char, strlen (arg
) + 2);
3060 new_option
[0] = 'W';
3061 strcpy (new_option
+ 1, arg
);
3062 option_index
= find_opt (new_option
, lang_mask
);
3063 if (option_index
== OPT_SPECIAL_unknown
)
3064 error_at (loc
, "-Werror=%s: no option -%s", arg
, new_option
);
3065 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
3066 error_at (loc
, "-Werror=%s: -%s is not an option that controls warnings",
3070 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
3071 const char *arg
= NULL
;
3073 if (cl_options
[option_index
].flags
& CL_JOINED
)
3074 arg
= new_option
+ cl_options
[option_index
].opt_len
;
3075 control_warning_option (option_index
, (int) kind
, arg
, value
,
3077 handlers
, opts
, opts_set
, dc
);
3082 /* Return malloced memory for the name of the option OPTION_INDEX
3083 which enabled a diagnostic (context CONTEXT), originally of type
3084 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
3088 option_name (diagnostic_context
*context
, int option_index
,
3089 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
3093 /* A warning classified as an error. */
3094 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
3095 && diag_kind
== DK_ERROR
)
3096 return concat (cl_options
[OPT_Werror_
].opt_text
,
3097 /* Skip over "-W". */
3098 cl_options
[option_index
].opt_text
+ 2,
3100 /* A warning with option. */
3102 return xstrdup (cl_options
[option_index
].opt_text
);
3104 /* A warning without option classified as an error. */
3105 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
3106 || diag_kind
== DK_WARNING
)
3107 && context
->warning_as_error_requested
)
3108 return xstrdup (cl_options
[OPT_Werror
].opt_text
);