1 /* Command line option handling.
2 Copyright (C) 2002-2017 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. */
440 static const struct default_options default_options_table
[] =
442 /* -O1 optimizations. */
443 { OPT_LEVELS_1_PLUS
, OPT_fdefer_pop
, NULL
, 1 },
445 { OPT_LEVELS_1_PLUS
, OPT_fdelayed_branch
, NULL
, 1 },
447 { OPT_LEVELS_1_PLUS
, OPT_fguess_branch_probability
, NULL
, 1 },
448 { OPT_LEVELS_1_PLUS
, OPT_fcprop_registers
, NULL
, 1 },
449 { OPT_LEVELS_1_PLUS
, OPT_fforward_propagate
, NULL
, 1 },
450 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion
, NULL
, 1 },
451 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion2
, NULL
, 1 },
452 { OPT_LEVELS_1_PLUS
, OPT_fipa_pure_const
, NULL
, 1 },
453 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference
, NULL
, 1 },
454 { OPT_LEVELS_1_PLUS
, OPT_fipa_profile
, NULL
, 1 },
455 { OPT_LEVELS_1_PLUS
, OPT_fmerge_constants
, NULL
, 1 },
456 { OPT_LEVELS_1_PLUS
, OPT_freorder_blocks
, NULL
, 1 },
457 { OPT_LEVELS_1_PLUS
, OPT_fshrink_wrap
, NULL
, 1 },
458 { OPT_LEVELS_1_PLUS
, OPT_fsplit_wide_types
, NULL
, 1 },
459 { OPT_LEVELS_1_PLUS
, OPT_ftree_ccp
, NULL
, 1 },
460 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_bit_ccp
, NULL
, 1 },
461 { OPT_LEVELS_1_PLUS
, OPT_ftree_coalesce_vars
, NULL
, 1 },
462 { OPT_LEVELS_1_PLUS
, OPT_ftree_dce
, NULL
, 1 },
463 { OPT_LEVELS_1_PLUS
, OPT_ftree_dominator_opts
, NULL
, 1 },
464 { OPT_LEVELS_1_PLUS
, OPT_ftree_dse
, NULL
, 1 },
465 { OPT_LEVELS_1_PLUS
, OPT_ftree_ter
, NULL
, 1 },
466 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_sra
, NULL
, 1 },
467 { OPT_LEVELS_1_PLUS
, OPT_ftree_fre
, NULL
, 1 },
468 { OPT_LEVELS_1_PLUS
, OPT_ftree_copy_prop
, NULL
, 1 },
469 { OPT_LEVELS_1_PLUS
, OPT_ftree_sink
, NULL
, 1 },
470 { OPT_LEVELS_1_PLUS
, OPT_ftree_ch
, NULL
, 1 },
471 { OPT_LEVELS_1_PLUS
, OPT_fcombine_stack_adjustments
, NULL
, 1 },
472 { OPT_LEVELS_1_PLUS
, OPT_fcompare_elim
, NULL
, 1 },
473 { OPT_LEVELS_1_PLUS
, OPT_ftree_slsr
, NULL
, 1 },
474 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fbranch_count_reg
, NULL
, 1 },
475 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_invariants
, NULL
, 1 },
476 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_pta
, NULL
, 1 },
477 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fssa_phiopt
, NULL
, 1 },
478 { OPT_LEVELS_1_PLUS
, OPT_ftree_builtin_call_dce
, NULL
, 1 },
479 { OPT_LEVELS_1_PLUS
, OPT_fomit_frame_pointer
, NULL
, 1 },
481 /* -O2 optimizations. */
482 { OPT_LEVELS_2_PLUS
, OPT_finline_small_functions
, NULL
, 1 },
483 { OPT_LEVELS_2_PLUS
, OPT_findirect_inlining
, NULL
, 1 },
484 { OPT_LEVELS_2_PLUS
, OPT_fpartial_inlining
, NULL
, 1 },
485 { OPT_LEVELS_2_PLUS
, OPT_fthread_jumps
, NULL
, 1 },
486 { OPT_LEVELS_2_PLUS
, OPT_fcrossjumping
, NULL
, 1 },
487 { OPT_LEVELS_2_PLUS
, OPT_foptimize_sibling_calls
, NULL
, 1 },
488 { OPT_LEVELS_2_PLUS
, OPT_fcse_follow_jumps
, NULL
, 1 },
489 { OPT_LEVELS_2_PLUS
, OPT_fgcse
, NULL
, 1 },
490 { OPT_LEVELS_2_PLUS
, OPT_fexpensive_optimizations
, NULL
, 1 },
491 { OPT_LEVELS_2_PLUS
, OPT_frerun_cse_after_loop
, NULL
, 1 },
492 { OPT_LEVELS_2_PLUS
, OPT_fcaller_saves
, NULL
, 1 },
493 { OPT_LEVELS_2_PLUS
, OPT_fpeephole2
, NULL
, 1 },
494 #ifdef INSN_SCHEDULING
495 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
496 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_fschedule_insns
, NULL
, 1 },
497 { OPT_LEVELS_2_PLUS
, OPT_fschedule_insns2
, NULL
, 1 },
499 { OPT_LEVELS_2_PLUS
, OPT_fstrict_aliasing
, NULL
, 1 },
500 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_freorder_blocks_algorithm_
, NULL
,
501 REORDER_BLOCKS_ALGORITHM_STC
},
502 { OPT_LEVELS_2_PLUS
, OPT_freorder_functions
, NULL
, 1 },
503 { OPT_LEVELS_2_PLUS
, OPT_ftree_vrp
, NULL
, 1 },
504 { OPT_LEVELS_2_PLUS
, OPT_fcode_hoisting
, NULL
, 1 },
505 { OPT_LEVELS_2_PLUS
, OPT_ftree_pre
, NULL
, 1 },
506 { OPT_LEVELS_2_PLUS
, OPT_ftree_switch_conversion
, NULL
, 1 },
507 { OPT_LEVELS_2_PLUS
, OPT_fipa_cp
, NULL
, 1 },
508 { OPT_LEVELS_2_PLUS
, OPT_fipa_bit_cp
, NULL
, 1 },
509 { OPT_LEVELS_2_PLUS
, OPT_fipa_vrp
, NULL
, 1 },
510 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize
, NULL
, 1 },
511 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize_speculatively
, NULL
, 1 },
512 { OPT_LEVELS_2_PLUS
, OPT_fipa_sra
, NULL
, 1 },
513 { OPT_LEVELS_2_PLUS
, OPT_falign_loops
, NULL
, 1 },
514 { OPT_LEVELS_2_PLUS
, OPT_falign_jumps
, NULL
, 1 },
515 { OPT_LEVELS_2_PLUS
, OPT_falign_labels
, NULL
, 1 },
516 { OPT_LEVELS_2_PLUS
, OPT_falign_functions
, NULL
, 1 },
517 { OPT_LEVELS_2_PLUS
, OPT_ftree_tail_merge
, NULL
, 1 },
518 { OPT_LEVELS_2_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_CHEAP
},
519 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_foptimize_strlen
, NULL
, 1 },
520 { OPT_LEVELS_2_PLUS
, OPT_fhoist_adjacent_loads
, NULL
, 1 },
521 { OPT_LEVELS_2_PLUS
, OPT_fipa_icf
, NULL
, 1 },
522 { OPT_LEVELS_2_PLUS
, OPT_fisolate_erroneous_paths_dereference
, NULL
, 1 },
523 { OPT_LEVELS_2_PLUS
, OPT_fipa_ra
, NULL
, 1 },
524 { OPT_LEVELS_2_PLUS
, OPT_flra_remat
, NULL
, 1 },
525 { OPT_LEVELS_2_PLUS
, OPT_fstore_merging
, NULL
, 1 },
527 /* -O3 optimizations. */
528 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribute_patterns
, NULL
, 1 },
529 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribution
, NULL
, 1 },
530 { OPT_LEVELS_3_PLUS
, OPT_floop_interchange
, NULL
, 1 },
531 { OPT_LEVELS_3_PLUS
, OPT_fpredictive_commoning
, NULL
, 1 },
532 { OPT_LEVELS_3_PLUS
, OPT_fsplit_paths
, NULL
, 1 },
533 /* Inlining of functions reducing size is a good idea with -Os
534 regardless of them being declared inline. */
535 { OPT_LEVELS_3_PLUS_AND_SIZE
, OPT_finline_functions
, NULL
, 1 },
536 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_finline_functions_called_once
, NULL
, 1 },
537 { OPT_LEVELS_3_PLUS
, OPT_fsplit_loops
, NULL
, 1 },
538 { OPT_LEVELS_3_PLUS
, OPT_funswitch_loops
, NULL
, 1 },
539 { OPT_LEVELS_3_PLUS
, OPT_floop_unroll_and_jam
, NULL
, 1 },
540 { OPT_LEVELS_3_PLUS
, OPT_fgcse_after_reload
, NULL
, 1 },
541 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_vectorize
, NULL
, 1 },
542 { OPT_LEVELS_3_PLUS
, OPT_ftree_slp_vectorize
, NULL
, 1 },
543 { OPT_LEVELS_3_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_DYNAMIC
},
544 { OPT_LEVELS_3_PLUS
, OPT_fipa_cp_clone
, NULL
, 1 },
545 { OPT_LEVELS_3_PLUS
, OPT_ftree_partial_pre
, NULL
, 1 },
546 { OPT_LEVELS_3_PLUS
, OPT_fpeel_loops
, NULL
, 1 },
548 /* -Ofast adds optimizations to -O3. */
549 { OPT_LEVELS_FAST
, OPT_ffast_math
, NULL
, 1 },
551 { OPT_LEVELS_NONE
, 0, NULL
, 0 }
554 /* Default the options in OPTS and OPTS_SET based on the optimization
555 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
557 default_options_optimization (struct gcc_options
*opts
,
558 struct gcc_options
*opts_set
,
559 struct cl_decoded_option
*decoded_options
,
560 unsigned int decoded_options_count
,
562 unsigned int lang_mask
,
563 const struct cl_option_handlers
*handlers
,
564 diagnostic_context
*dc
)
568 bool openacc_mode
= false;
570 /* Scan to see what optimization level has been specified. That will
571 determine the default value of many flags. */
572 for (i
= 1; i
< decoded_options_count
; i
++)
574 struct cl_decoded_option
*opt
= &decoded_options
[i
];
575 switch (opt
->opt_index
)
578 if (*opt
->arg
== '\0')
580 opts
->x_optimize
= 1;
581 opts
->x_optimize_size
= 0;
582 opts
->x_optimize_fast
= 0;
583 opts
->x_optimize_debug
= 0;
587 const int optimize_val
= integral_argument (opt
->arg
);
588 if (optimize_val
== -1)
589 error_at (loc
, "argument to %<-O%> should be a non-negative "
590 "integer, %<g%>, %<s%> or %<fast%>");
593 opts
->x_optimize
= optimize_val
;
594 if ((unsigned int) opts
->x_optimize
> 255)
595 opts
->x_optimize
= 255;
596 opts
->x_optimize_size
= 0;
597 opts
->x_optimize_fast
= 0;
598 opts
->x_optimize_debug
= 0;
604 opts
->x_optimize_size
= 1;
606 /* Optimizing for size forces optimize to be 2. */
607 opts
->x_optimize
= 2;
608 opts
->x_optimize_fast
= 0;
609 opts
->x_optimize_debug
= 0;
613 /* -Ofast only adds flags to -O3. */
614 opts
->x_optimize_size
= 0;
615 opts
->x_optimize
= 3;
616 opts
->x_optimize_fast
= 1;
617 opts
->x_optimize_debug
= 0;
621 /* -Og selects optimization level 1. */
622 opts
->x_optimize_size
= 0;
623 opts
->x_optimize
= 1;
624 opts
->x_optimize_fast
= 0;
625 opts
->x_optimize_debug
= 1;
634 /* Ignore other options in this prescan. */
639 maybe_default_options (opts
, opts_set
, default_options_table
,
640 opts
->x_optimize
, opts
->x_optimize_size
,
641 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
642 lang_mask
, handlers
, loc
, dc
);
644 /* -O2 param settings. */
645 opt2
= (opts
->x_optimize
>= 2);
648 && !opts_set
->x_flag_ipa_pta
)
649 opts
->x_flag_ipa_pta
= true;
651 /* Track fields in field-sensitive alias analysis. */
652 maybe_set_param_value
653 (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
,
654 opt2
? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
),
655 opts
->x_param_values
, opts_set
->x_param_values
);
657 /* For -O1 only do loop invariant motion for very small loops. */
658 maybe_set_param_value
659 (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
,
660 opt2
? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
) : 1000,
661 opts
->x_param_values
, opts_set
->x_param_values
);
663 /* At -Ofast, allow store motion to introduce potential race conditions. */
664 maybe_set_param_value
665 (PARAM_ALLOW_STORE_DATA_RACES
,
666 opts
->x_optimize_fast
? 1
667 : default_param_value (PARAM_ALLOW_STORE_DATA_RACES
),
668 opts
->x_param_values
, opts_set
->x_param_values
);
670 if (opts
->x_optimize_size
)
671 /* We want to crossjump as much as possible. */
672 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
, 1,
673 opts
->x_param_values
, opts_set
->x_param_values
);
675 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
,
676 default_param_value (PARAM_MIN_CROSSJUMP_INSNS
),
677 opts
->x_param_values
, opts_set
->x_param_values
);
679 /* Restrict the amount of work combine does at -Og while retaining
680 most of its useful transforms. */
681 if (opts
->x_optimize_debug
)
682 maybe_set_param_value (PARAM_MAX_COMBINE_INSNS
, 2,
683 opts
->x_param_values
, opts_set
->x_param_values
);
685 /* Allow default optimizations to be specified on a per-machine basis. */
686 maybe_default_options (opts
, opts_set
,
687 targetm_common
.option_optimization_table
,
688 opts
->x_optimize
, opts
->x_optimize_size
,
689 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
690 lang_mask
, handlers
, loc
, dc
);
693 /* After all options at LOC have been read into OPTS and OPTS_SET,
694 finalize settings of those options and diagnose incompatible
697 finish_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
700 enum unwind_info_type ui_except
;
702 if (opts
->x_dump_base_name
703 && ! IS_ABSOLUTE_PATH (opts
->x_dump_base_name
)
704 && ! opts
->x_dump_base_name_prefixed
)
706 /* First try to make OPTS->X_DUMP_BASE_NAME relative to the
707 OPTS->X_DUMP_DIR_NAME directory. Then try to make
708 OPTS->X_DUMP_BASE_NAME relative to the OPTS->X_AUX_BASE_NAME
709 directory, typically the directory to contain the object
711 if (opts
->x_dump_dir_name
)
712 opts
->x_dump_base_name
= opts_concat (opts
->x_dump_dir_name
,
713 opts
->x_dump_base_name
, NULL
);
714 else if (opts
->x_aux_base_name
715 && strcmp (opts
->x_aux_base_name
, HOST_BIT_BUCKET
) != 0)
717 const char *aux_base
;
719 base_of_path (opts
->x_aux_base_name
, &aux_base
);
720 if (opts
->x_aux_base_name
!= aux_base
)
722 int dir_len
= aux_base
- opts
->x_aux_base_name
;
723 char *new_dump_base_name
724 = XOBNEWVEC (&opts_obstack
, char,
725 strlen (opts
->x_dump_base_name
) + dir_len
+ 1);
727 /* Copy directory component from OPTS->X_AUX_BASE_NAME. */
728 memcpy (new_dump_base_name
, opts
->x_aux_base_name
, dir_len
);
729 /* Append existing OPTS->X_DUMP_BASE_NAME. */
730 strcpy (new_dump_base_name
+ dir_len
, opts
->x_dump_base_name
);
731 opts
->x_dump_base_name
= new_dump_base_name
;
734 opts
->x_dump_base_name_prefixed
= true;
737 /* Handle related options for unit-at-a-time, toplevel-reorder, and
739 if (!opts
->x_flag_unit_at_a_time
)
741 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
742 error_at (loc
, "section anchors must be disabled when unit-at-a-time "
744 opts
->x_flag_section_anchors
= 0;
745 if (opts
->x_flag_toplevel_reorder
== 1)
746 error_at (loc
, "toplevel reorder must be disabled when unit-at-a-time "
748 opts
->x_flag_toplevel_reorder
= 0;
751 /* -fself-test depends on the state of the compiler prior to
752 compiling anything. Ideally it should be run on an empty source
753 file. However, in case we get run with actual source, assume
754 -fsyntax-only which will inhibit any compiler initialization
755 which may confuse the self tests. */
756 if (opts
->x_flag_self_test
)
757 opts
->x_flag_syntax_only
= 1;
759 if (opts
->x_flag_tm
&& opts
->x_flag_non_call_exceptions
)
760 sorry ("transactional memory is not supported with non-call exceptions");
762 /* Unless the user has asked for section anchors, we disable toplevel
763 reordering at -O0 to disable transformations that might be surprising
764 to end users and to get -fno-toplevel-reorder tested. */
765 if (!opts
->x_optimize
766 && opts
->x_flag_toplevel_reorder
== 2
767 && !(opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
))
769 opts
->x_flag_toplevel_reorder
= 0;
770 opts
->x_flag_section_anchors
= 0;
772 if (!opts
->x_flag_toplevel_reorder
)
774 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
775 error_at (loc
, "section anchors must be disabled when toplevel reorder"
777 opts
->x_flag_section_anchors
= 0;
780 if (!opts
->x_flag_opts_finished
)
782 /* We initialize opts->x_flag_pie to -1 so that targets can set a
784 if (opts
->x_flag_pie
== -1)
786 /* We initialize opts->x_flag_pic to -1 so that we can tell if
787 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
788 if (opts
->x_flag_pic
== -1)
789 opts
->x_flag_pie
= DEFAULT_FLAG_PIE
;
791 opts
->x_flag_pie
= 0;
793 /* If -fPIE or -fpie is used, turn on PIC. */
794 if (opts
->x_flag_pie
)
795 opts
->x_flag_pic
= opts
->x_flag_pie
;
796 else if (opts
->x_flag_pic
== -1)
797 opts
->x_flag_pic
= 0;
798 if (opts
->x_flag_pic
&& !opts
->x_flag_pie
)
799 opts
->x_flag_shlib
= 1;
800 opts
->x_flag_opts_finished
= true;
803 /* We initialize opts->x_flag_stack_protect to -1 so that targets
804 can set a default value. */
805 if (opts
->x_flag_stack_protect
== -1)
806 opts
->x_flag_stack_protect
= DEFAULT_FLAG_SSP
;
808 if (opts
->x_optimize
== 0)
810 /* Inlining does not work if not optimizing,
811 so force it not to be done. */
812 opts
->x_warn_inline
= 0;
813 opts
->x_flag_no_inline
= 1;
816 /* The optimization to partition hot and cold basic blocks into separate
817 sections of the .o and executable files does not work (currently)
818 with exception handling. This is because there is no support for
819 generating unwind info. If opts->x_flag_exceptions is turned on
820 we need to turn off the partitioning optimization. */
822 ui_except
= targetm_common
.except_unwind_info (opts
);
824 if (opts
->x_flag_exceptions
825 && opts
->x_flag_reorder_blocks_and_partition
826 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
828 if (opts_set
->x_flag_reorder_blocks_and_partition
)
830 "%<-freorder-blocks-and-partition%> does not work "
831 "with exceptions on this architecture");
832 opts
->x_flag_reorder_blocks_and_partition
= 0;
833 opts
->x_flag_reorder_blocks
= 1;
836 /* If user requested unwind info, then turn off the partitioning
839 if (opts
->x_flag_unwind_tables
840 && !targetm_common
.unwind_tables_default
841 && opts
->x_flag_reorder_blocks_and_partition
842 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
844 if (opts_set
->x_flag_reorder_blocks_and_partition
)
846 "%<-freorder-blocks-and-partition%> does not support "
847 "unwind info on this architecture");
848 opts
->x_flag_reorder_blocks_and_partition
= 0;
849 opts
->x_flag_reorder_blocks
= 1;
852 /* If the target requested unwind info, then turn off the partitioning
853 optimization with a different message. Likewise, if the target does not
854 support named sections. */
856 if (opts
->x_flag_reorder_blocks_and_partition
857 && (!targetm_common
.have_named_sections
858 || (opts
->x_flag_unwind_tables
859 && targetm_common
.unwind_tables_default
860 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
862 if (opts_set
->x_flag_reorder_blocks_and_partition
)
864 "%<-freorder-blocks-and-partition%> does not work "
865 "on this architecture");
866 opts
->x_flag_reorder_blocks_and_partition
= 0;
867 opts
->x_flag_reorder_blocks
= 1;
871 /* Pipelining of outer loops is only possible when general pipelining
872 capabilities are requested. */
873 if (!opts
->x_flag_sel_sched_pipelining
)
874 opts
->x_flag_sel_sched_pipelining_outer_loops
= 0;
876 if (opts
->x_flag_conserve_stack
)
878 maybe_set_param_value (PARAM_LARGE_STACK_FRAME
, 100,
879 opts
->x_param_values
, opts_set
->x_param_values
);
880 maybe_set_param_value (PARAM_STACK_FRAME_GROWTH
, 40,
881 opts
->x_param_values
, opts_set
->x_param_values
);
884 if (opts
->x_flag_lto
)
887 opts
->x_flag_generate_lto
= 1;
889 /* When generating IL, do not operate in whole-program mode.
890 Otherwise, symbols will be privatized too early, causing link
892 opts
->x_flag_whole_program
= 0;
894 error_at (loc
, "LTO support has not been enabled in this configuration");
896 if (!opts
->x_flag_fat_lto_objects
898 || (opts_set
->x_flag_use_linker_plugin
899 && !opts
->x_flag_use_linker_plugin
)))
901 if (opts_set
->x_flag_fat_lto_objects
)
902 error_at (loc
, "%<-fno-fat-lto-objects%> are supported only with "
904 opts
->x_flag_fat_lto_objects
= 1;
908 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
909 default value if they choose based on other options. */
910 if (opts
->x_flag_split_stack
== -1)
911 opts
->x_flag_split_stack
= 0;
912 else if (opts
->x_flag_split_stack
)
914 if (!targetm_common
.supports_split_stack (true, opts
))
916 error_at (loc
, "%<-fsplit-stack%> is not supported by "
917 "this compiler configuration");
918 opts
->x_flag_split_stack
= 0;
922 /* If stack splitting is turned on, and the user did not explicitly
923 request function partitioning, turn off partitioning, as it
924 confuses the linker when trying to handle partitioned split-stack
925 code that calls a non-split-stack functions. But if partitioning
926 was turned on explicitly just hope for the best. */
927 if (opts
->x_flag_split_stack
928 && opts
->x_flag_reorder_blocks_and_partition
929 && !opts_set
->x_flag_reorder_blocks_and_partition
)
930 opts
->x_flag_reorder_blocks_and_partition
= 0;
932 if (opts
->x_flag_reorder_blocks_and_partition
933 && !opts_set
->x_flag_reorder_functions
)
934 opts
->x_flag_reorder_functions
= 1;
936 /* Tune vectorization related parametees according to cost model. */
937 if (opts
->x_flag_vect_cost_model
== VECT_COST_MODEL_CHEAP
)
939 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS
,
940 6, opts
->x_param_values
, opts_set
->x_param_values
);
941 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS
,
942 0, opts
->x_param_values
, opts_set
->x_param_values
);
943 maybe_set_param_value (PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT
,
944 0, opts
->x_param_values
, opts_set
->x_param_values
);
947 /* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
949 if ((!opts
->x_flag_tree_loop_vectorize
&& !opts
->x_flag_tree_slp_vectorize
)
950 || !opts
->x_flag_tree_loop_if_convert
)
951 maybe_set_param_value (PARAM_MAX_STORES_TO_SINK
, 0,
952 opts
->x_param_values
, opts_set
->x_param_values
);
954 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
955 if (opts
->x_dwarf_split_debug_info
)
956 opts
->x_debug_generate_pub_sections
= 2;
958 if ((opts
->x_flag_sanitize
959 & (SANITIZE_USER_ADDRESS
| SANITIZE_KERNEL_ADDRESS
)) == 0)
961 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_COMPARE
)
963 "%<-fsanitize=pointer-compare%> must be combined with "
964 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
965 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_SUBTRACT
)
967 "%<-fsanitize=pointer-subtract%> must be combined with "
968 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
971 /* Userspace and kernel ASan conflict with each other. */
972 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
973 && (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
))
975 "%<-fsanitize=address%> is incompatible with "
976 "%<-fsanitize=kernel-address%>");
979 if ((opts
->x_flag_sanitize
& SANITIZE_ADDRESS
)
980 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
982 "%<-fsanitize=address%> and %<-fsanitize=kernel-address%> "
983 "are incompatible with %<-fsanitize=thread%>");
985 if ((opts
->x_flag_sanitize
& SANITIZE_LEAK
)
986 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
988 "%<-fsanitize=leak%> is incompatible with %<-fsanitize=thread%>");
990 /* Check error recovery for -fsanitize-recover option. */
991 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
992 if ((opts
->x_flag_sanitize_recover
& sanitizer_opts
[i
].flag
)
993 && !sanitizer_opts
[i
].can_recover
)
994 error_at (loc
, "%<-fsanitize-recover=%s%> is not supported",
995 sanitizer_opts
[i
].name
);
997 /* When instrumenting the pointers, we don't want to remove
998 the null pointer checks. */
999 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
1000 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
1001 opts
->x_flag_delete_null_pointer_checks
= 0;
1003 /* Aggressive compiler optimizations may cause false negatives. */
1004 if (opts
->x_flag_sanitize
& ~(SANITIZE_LEAK
| SANITIZE_UNREACHABLE
))
1005 opts
->x_flag_aggressive_loop_optimizations
= 0;
1007 /* Enable -fsanitize-address-use-after-scope if address sanitizer is
1009 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
1010 && !opts_set
->x_flag_sanitize_address_use_after_scope
)
1011 opts
->x_flag_sanitize_address_use_after_scope
= true;
1013 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1015 if (opts
->x_flag_sanitize_address_use_after_scope
)
1017 if (opts
->x_flag_stack_reuse
!= SR_NONE
1018 && opts_set
->x_flag_stack_reuse
!= SR_NONE
)
1020 "%<-fsanitize-address-use-after-scope%> requires "
1021 "%<-fstack-reuse=none%> option");
1023 opts
->x_flag_stack_reuse
= SR_NONE
;
1026 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
) && opts
->x_flag_tm
)
1027 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1029 if ((opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) && opts
->x_flag_tm
)
1030 sorry ("transactional memory is not supported with "
1031 "%<-fsanitize=kernel-address%>");
1034 #define LEFT_COLUMN 27
1036 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1037 followed by word-wrapped HELP in a second column. */
1039 wrap_help (const char *help
,
1041 unsigned int item_width
,
1042 unsigned int columns
)
1044 unsigned int col_width
= LEFT_COLUMN
;
1045 unsigned int remaining
, room
, len
;
1047 remaining
= strlen (help
);
1051 room
= columns
- 3 - MAX (col_width
, item_width
);
1060 for (i
= 0; help
[i
]; i
++)
1062 if (i
>= room
&& len
!= remaining
)
1066 else if ((help
[i
] == '-' || help
[i
] == '/')
1067 && help
[i
+ 1] != ' '
1068 && i
> 0 && ISALPHA (help
[i
- 1]))
1073 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1075 while (help
[len
] == ' ')
1083 /* Print help for a specific front-end, etc. */
1085 print_filtered_help (unsigned int include_flags
,
1086 unsigned int exclude_flags
,
1087 unsigned int any_flags
,
1088 unsigned int columns
,
1089 struct gcc_options
*opts
,
1090 unsigned int lang_mask
)
1095 bool displayed
= false;
1098 if (include_flags
== CL_PARAMS
)
1100 for (i
= 0; i
< LAST_PARAM
; i
++)
1102 const char *param
= compiler_params
[i
].option
;
1104 help
= compiler_params
[i
].help
;
1105 if (help
== NULL
|| *help
== '\0')
1107 if (exclude_flags
& CL_UNDOCUMENTED
)
1109 help
= undocumented_msg
;
1112 /* Get the translation. */
1115 if (!opts
->x_quiet_flag
)
1117 snprintf (new_help
, sizeof (new_help
),
1118 _("default %d minimum %d maximum %d"),
1119 compiler_params
[i
].default_value
,
1120 compiler_params
[i
].min_value
,
1121 compiler_params
[i
].max_value
);
1124 wrap_help (help
, param
, strlen (param
), columns
);
1130 if (!opts
->x_help_printed
)
1131 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1133 if (!opts
->x_help_enum_printed
)
1134 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1136 for (i
= 0; i
< cl_options_count
; i
++)
1138 const struct cl_option
*option
= cl_options
+ i
;
1143 if (include_flags
== 0
1144 || ((option
->flags
& include_flags
) != include_flags
))
1146 if ((option
->flags
& any_flags
) == 0)
1150 /* Skip unwanted switches. */
1151 if ((option
->flags
& exclude_flags
) != 0)
1154 /* The driver currently prints its own help text. */
1155 if ((option
->flags
& CL_DRIVER
) != 0
1156 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1157 | CL_COMMON
| CL_TARGET
)) == 0)
1161 /* Skip switches that have already been printed. */
1162 if (opts
->x_help_printed
[i
])
1165 opts
->x_help_printed
[i
] = true;
1167 help
= option
->help
;
1170 if (exclude_flags
& CL_UNDOCUMENTED
)
1173 help
= undocumented_msg
;
1176 if (option
->alias_target
< N_OPTS
1177 && cl_options
[option
->alias_target
].help
)
1179 if (help
== undocumented_msg
)
1181 /* For undocumented options that are aliases for other options
1182 that are documented, point the reader to the other option in
1183 preference of the former. */
1184 snprintf (new_help
, sizeof new_help
,
1185 _("Same as %s. Use the latter option instead."),
1186 cl_options
[option
->alias_target
].opt_text
);
1190 /* For documented options with aliases, mention the aliased
1191 option's name for reference. */
1192 snprintf (new_help
, sizeof new_help
,
1193 _("%s Same as %s."),
1194 help
, cl_options
[option
->alias_target
].opt_text
);
1200 if (option
->warn_message
)
1202 /* Mention that the use of the option will trigger a warning. */
1203 if (help
== new_help
)
1204 snprintf (new_help
+ strlen (new_help
),
1205 sizeof new_help
- strlen (new_help
),
1206 " %s", _(use_diagnosed_msg
));
1208 snprintf (new_help
, sizeof new_help
,
1209 "%s %s", help
, _(use_diagnosed_msg
));
1214 /* Get the translation. */
1217 /* Find the gap between the name of the
1218 option and its descriptive text. */
1219 tab
= strchr (help
, '\t');
1228 opt
= option
->opt_text
;
1232 /* With the -Q option enabled we change the descriptive text associated
1233 with an option to be an indication of its current setting. */
1234 if (!opts
->x_quiet_flag
)
1236 void *flag_var
= option_flag_var (i
, opts
);
1238 if (len
< (LEFT_COLUMN
+ 2))
1239 strcpy (new_help
, "\t\t");
1241 strcpy (new_help
, "\t");
1243 if (flag_var
!= NULL
1244 && option
->var_type
!= CLVC_DEFER
)
1246 if (option
->flags
& CL_JOINED
)
1248 if (option
->var_type
== CLVC_STRING
)
1250 if (* (const char **) flag_var
!= NULL
)
1251 snprintf (new_help
+ strlen (new_help
),
1252 sizeof (new_help
) - strlen (new_help
),
1253 "%s", * (const char **) flag_var
);
1255 else if (option
->var_type
== CLVC_ENUM
)
1257 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1259 const char *arg
= NULL
;
1261 value
= e
->get (flag_var
);
1262 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1264 arg
= _("[default]");
1265 snprintf (new_help
+ strlen (new_help
),
1266 sizeof (new_help
) - strlen (new_help
),
1270 sprintf (new_help
+ strlen (new_help
),
1271 "%d", * (int *) flag_var
);
1274 strcat (new_help
, option_enabled (i
, opts
)
1275 ? _("[enabled]") : _("[disabled]"));
1281 if (option
->range_max
!= -1)
1284 snprintf (b
, sizeof (b
), "<%d,%d>", option
->range_min
,
1286 opt
= concat (opt
, b
, NULL
);
1290 wrap_help (help
, opt
, len
, columns
);
1293 if (option
->var_type
== CLVC_ENUM
1294 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1295 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1300 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1303 printf (_(" No options with the desired characteristics were found\n"));
1308 /* PR 31349: Tell the user how to see all of the
1309 options supported by a specific front end. */
1310 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1311 if ((1U << i
) & langs
)
1312 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1313 lang_names
[i
], lang_names
[i
]);
1317 else if (! displayed
)
1318 printf (_(" All options with the desired characteristics have already been displayed\n"));
1322 /* Print details of enumerated option arguments, if those
1323 enumerations have help text headings provided. If no help text
1324 is provided, presume that the possible values are listed in the
1325 help text for the relevant options. */
1326 for (i
= 0; i
< cl_enums_count
; i
++)
1328 unsigned int j
, pos
;
1330 if (opts
->x_help_enum_printed
[i
] != 1)
1332 if (cl_enums
[i
].help
== NULL
)
1334 printf (" %s\n ", _(cl_enums
[i
].help
));
1336 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1338 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1340 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1342 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1352 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1357 opts
->x_help_enum_printed
[i
] = 2;
1361 /* Display help for a specified type of option.
1362 The options must have ALL of the INCLUDE_FLAGS set
1363 ANY of the flags in the ANY_FLAGS set
1364 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1365 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1367 print_specific_help (unsigned int include_flags
,
1368 unsigned int exclude_flags
,
1369 unsigned int any_flags
,
1370 struct gcc_options
*opts
,
1371 unsigned int lang_mask
)
1373 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1374 const char * description
= NULL
;
1375 const char * descrip_extra
= "";
1379 /* Sanity check: Make sure that we do not have more
1380 languages than we have bits available to enumerate them. */
1381 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1383 /* If we have not done so already, obtain
1384 the desired maximum width of the output. */
1385 if (opts
->x_help_columns
== 0)
1387 opts
->x_help_columns
= get_terminal_width ();
1388 if (opts
->x_help_columns
== INT_MAX
)
1389 /* Use a reasonable default. */
1390 opts
->x_help_columns
= 80;
1393 /* Decide upon the title for the options that we are going to display. */
1394 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1396 switch (flag
& include_flags
)
1403 description
= _("The following options are target specific");
1406 description
= _("The following options control compiler warning messages");
1408 case CL_OPTIMIZATION
:
1409 description
= _("The following options control optimizations");
1412 description
= _("The following options are language-independent");
1415 description
= _("The --param option recognizes the following as parameters");
1418 if (i
>= cl_lang_count
)
1420 if (exclude_flags
& all_langs_mask
)
1421 description
= _("The following options are specific to just the language ");
1423 description
= _("The following options are supported by the language ");
1424 descrip_extra
= lang_names
[i
];
1429 if (description
== NULL
)
1433 if (include_flags
& CL_UNDOCUMENTED
)
1434 description
= _("The following options are not documented");
1435 else if (include_flags
& CL_SEPARATE
)
1436 description
= _("The following options take separate arguments");
1437 else if (include_flags
& CL_JOINED
)
1438 description
= _("The following options take joined arguments");
1441 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1448 if (any_flags
& all_langs_mask
)
1449 description
= _("The following options are language-related");
1451 description
= _("The following options are language-independent");
1455 printf ("%s%s:\n", description
, descrip_extra
);
1456 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
1457 opts
->x_help_columns
, opts
, lang_mask
);
1460 /* Enable FDO-related flags. */
1463 enable_fdo_optimizations (struct gcc_options
*opts
,
1464 struct gcc_options
*opts_set
,
1467 if (!opts_set
->x_flag_branch_probabilities
)
1468 opts
->x_flag_branch_probabilities
= value
;
1469 if (!opts_set
->x_flag_profile_values
)
1470 opts
->x_flag_profile_values
= value
;
1471 if (!opts_set
->x_flag_unroll_loops
)
1472 opts
->x_flag_unroll_loops
= value
;
1473 if (!opts_set
->x_flag_peel_loops
)
1474 opts
->x_flag_peel_loops
= value
;
1475 if (!opts_set
->x_flag_tracer
)
1476 opts
->x_flag_tracer
= value
;
1477 if (!opts_set
->x_flag_value_profile_transformations
)
1478 opts
->x_flag_value_profile_transformations
= value
;
1479 if (!opts_set
->x_flag_inline_functions
)
1480 opts
->x_flag_inline_functions
= value
;
1481 if (!opts_set
->x_flag_ipa_cp
)
1482 opts
->x_flag_ipa_cp
= value
;
1483 if (!opts_set
->x_flag_ipa_cp_clone
1484 && value
&& opts
->x_flag_ipa_cp
)
1485 opts
->x_flag_ipa_cp_clone
= value
;
1486 if (!opts_set
->x_flag_ipa_bit_cp
1487 && value
&& opts
->x_flag_ipa_cp
)
1488 opts
->x_flag_ipa_bit_cp
= value
;
1489 if (!opts_set
->x_flag_predictive_commoning
)
1490 opts
->x_flag_predictive_commoning
= value
;
1491 if (!opts_set
->x_flag_split_loops
)
1492 opts
->x_flag_split_loops
= value
;
1493 if (!opts_set
->x_flag_unswitch_loops
)
1494 opts
->x_flag_unswitch_loops
= value
;
1495 if (!opts_set
->x_flag_gcse_after_reload
)
1496 opts
->x_flag_gcse_after_reload
= value
;
1497 if (!opts_set
->x_flag_tree_loop_vectorize
)
1498 opts
->x_flag_tree_loop_vectorize
= value
;
1499 if (!opts_set
->x_flag_tree_slp_vectorize
)
1500 opts
->x_flag_tree_slp_vectorize
= value
;
1501 if (!opts_set
->x_flag_vect_cost_model
)
1502 opts
->x_flag_vect_cost_model
= VECT_COST_MODEL_DYNAMIC
;
1503 if (!opts_set
->x_flag_tree_loop_distribute_patterns
)
1504 opts
->x_flag_tree_loop_distribute_patterns
= value
;
1507 /* -f{,no-}sanitize{,-recover}= suboptions. */
1508 const struct sanitizer_opts_s sanitizer_opts
[] =
1510 #define SANITIZER_OPT(name, flags, recover) \
1511 { #name, flags, sizeof #name - 1, recover }
1512 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true),
1513 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
1515 SANITIZER_OPT (pointer
-compare
, SANITIZE_POINTER_COMPARE
, true),
1516 SANITIZER_OPT (pointer
-subtract
, SANITIZE_POINTER_SUBTRACT
, true),
1517 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false),
1518 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false),
1519 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true),
1520 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true),
1521 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true),
1522 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true),
1523 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true),
1524 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false),
1525 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true),
1526 SANITIZER_OPT (return, SANITIZE_RETURN
, false),
1527 SANITIZER_OPT (null
, SANITIZE_NULL
, true),
1528 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true),
1529 SANITIZER_OPT (bool, SANITIZE_BOOL
, true),
1530 SANITIZER_OPT (enum, SANITIZE_ENUM
, true),
1531 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true),
1532 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true),
1533 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true),
1534 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true),
1535 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true),
1536 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true),
1537 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
1539 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true),
1540 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true),
1541 SANITIZER_OPT (pointer
-overflow
, SANITIZE_POINTER_OVERFLOW
, true),
1542 SANITIZER_OPT (builtin
, SANITIZE_BUILTIN
, true),
1543 SANITIZER_OPT (all
, ~0U, true),
1544 #undef SANITIZER_OPT
1545 { NULL
, 0U, 0UL, false }
1548 /* -f{,no-}sanitize-coverage= suboptions. */
1549 const struct sanitizer_opts_s coverage_sanitizer_opts
[] =
1551 #define COVERAGE_SANITIZER_OPT(name, flags) \
1552 { #name, flags, sizeof #name - 1, true }
1553 COVERAGE_SANITIZER_OPT (trace
-pc
, SANITIZE_COV_TRACE_PC
),
1554 COVERAGE_SANITIZER_OPT (trace
-cmp
, SANITIZE_COV_TRACE_CMP
),
1555 #undef COVERAGE_SANITIZER_OPT
1556 { NULL
, 0U, 0UL, false }
1559 /* A struct for describing a run of chars within a string. */
1561 struct string_fragment
1563 string_fragment (const char *start
, size_t len
)
1564 : m_start (start
), m_len (len
) {}
1566 const char *m_start
;
1570 /* Specialization of edit_distance_traits for string_fragment,
1571 for use by get_closest_sanitizer_option. */
1574 struct edit_distance_traits
<const string_fragment
&>
1576 static size_t get_length (const string_fragment
&fragment
)
1578 return fragment
.m_len
;
1581 static const char *get_string (const string_fragment
&fragment
)
1583 return fragment
.m_start
;
1587 /* Given ARG, an unrecognized sanitizer option, return the best
1588 matching sanitizer option, or NULL if there isn't one.
1589 OPTS is array of candidate sanitizer options.
1590 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or
1591 OPT_fsanitize_coverage_.
1592 VALUE is non-zero for the regular form of the option, zero
1593 for the "no-" form (e.g. "-fno-sanitize-recover="). */
1596 get_closest_sanitizer_option (const string_fragment
&arg
,
1597 const struct sanitizer_opts_s
*opts
,
1598 enum opt_code code
, int value
)
1600 best_match
<const string_fragment
&, const char*> bm (arg
);
1601 for (int i
= 0; opts
[i
].name
!= NULL
; ++i
)
1603 /* -fsanitize=all is not valid, so don't offer it. */
1604 if (code
== OPT_fsanitize_
1605 && opts
[i
].flag
== ~0U
1609 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
1610 don't offer the non-recoverable options. */
1611 if (code
== OPT_fsanitize_recover_
1612 && !opts
[i
].can_recover
1616 bm
.consider (opts
[i
].name
);
1618 return bm
.get_best_meaningful_candidate ();
1621 /* Parse comma separated sanitizer suboptions from P for option SCODE,
1622 adjust previous FLAGS and return new ones. If COMPLAIN is false,
1623 don't issue diagnostics. */
1626 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
1627 unsigned int flags
, int value
, bool complain
)
1629 enum opt_code code
= (enum opt_code
) scode
;
1631 const struct sanitizer_opts_s
*opts
;
1632 if (code
== OPT_fsanitize_coverage_
)
1633 opts
= coverage_sanitizer_opts
;
1635 opts
= sanitizer_opts
;
1641 const char *comma
= strchr (p
, ',');
1653 /* Check to see if the string matches an option class name. */
1654 for (i
= 0; opts
[i
].name
!= NULL
; ++i
)
1655 if (len
== opts
[i
].len
&& memcmp (p
, opts
[i
].name
, len
) == 0)
1657 /* Handle both -fsanitize and -fno-sanitize cases. */
1658 if (value
&& opts
[i
].flag
== ~0U)
1660 if (code
== OPT_fsanitize_
)
1663 error_at (loc
, "%<-fsanitize=all%> option is not valid");
1666 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
1667 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
1671 /* Do not enable -fsanitize-recover=unreachable and
1672 -fsanitize-recover=return if -fsanitize-recover=undefined
1674 if (code
== OPT_fsanitize_recover_
1675 && opts
[i
].flag
== SANITIZE_UNDEFINED
)
1676 flags
|= (SANITIZE_UNDEFINED
1677 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
1679 flags
|= opts
[i
].flag
;
1682 flags
&= ~opts
[i
].flag
;
1687 if (! found
&& complain
)
1690 = get_closest_sanitizer_option (string_fragment (p
, len
),
1694 if (code
== OPT_fsanitize_recover_
)
1695 suffix
= "-recover";
1696 else if (code
== OPT_fsanitize_coverage_
)
1697 suffix
= "-coverage";
1703 "unrecognized argument to -f%ssanitize%s= option: %q.*s;"
1704 " did you mean %qs?",
1706 suffix
, (int) len
, p
, hint
);
1709 "unrecognized argument to -f%ssanitize%s= option: %q.*s",
1711 suffix
, (int) len
, p
);
1721 /* Parse string values of no_sanitize attribute passed in VALUE.
1722 Values are separated with comma. */
1725 parse_no_sanitize_attribute (char *value
)
1727 unsigned int flags
= 0;
1729 char *q
= strtok (value
, ",");
1733 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1734 if (strcmp (sanitizer_opts
[i
].name
, q
) == 0)
1736 flags
|= sanitizer_opts
[i
].flag
;
1737 if (sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
1738 flags
|= SANITIZE_UNDEFINED_NONDEFAULT
;
1742 if (sanitizer_opts
[i
].name
== NULL
)
1743 warning (OPT_Wattributes
,
1744 "%<%s%> attribute directive ignored", q
);
1746 q
= strtok (NULL
, ",");
1752 /* Handle target- and language-independent options. Return zero to
1753 generate an "unknown option" message. Only options that need
1754 extra handling need to be listed here; if you simply want
1755 DECODED->value assigned to a variable, it happens automatically. */
1758 common_handle_option (struct gcc_options
*opts
,
1759 struct gcc_options
*opts_set
,
1760 const struct cl_decoded_option
*decoded
,
1761 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
1763 const struct cl_option_handlers
*handlers
,
1764 diagnostic_context
*dc
,
1765 void (*target_option_override_hook
) (void))
1767 size_t scode
= decoded
->opt_index
;
1768 const char *arg
= decoded
->arg
;
1769 int value
= decoded
->value
;
1770 enum opt_code code
= (enum opt_code
) scode
;
1772 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
1777 handle_param (opts
, opts_set
, loc
, arg
);
1782 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1783 unsigned int undoc_mask
;
1786 if (lang_mask
== CL_DRIVER
)
1789 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
1792 target_option_override_hook ();
1793 /* First display any single language specific options. */
1794 for (i
= 0; i
< cl_lang_count
; i
++)
1796 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
1798 /* Next display any multi language specific options. */
1799 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
1800 /* Then display any remaining, non-language options. */
1801 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
1803 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
1804 opts
->x_exit_after_options
= true;
1808 case OPT__target_help
:
1809 if (lang_mask
== CL_DRIVER
)
1812 target_option_override_hook ();
1813 print_specific_help (CL_TARGET
, CL_UNDOCUMENTED
, 0, opts
, lang_mask
);
1814 opts
->x_exit_after_options
= true;
1819 const char *a
= arg
;
1820 unsigned int include_flags
= 0;
1821 /* Note - by default we include undocumented options when listing
1822 specific classes. If you only want to see documented options
1823 then add ",^undocumented" to the --help= option. E.g.:
1825 --help=target,^undocumented */
1826 unsigned int exclude_flags
= 0;
1828 if (lang_mask
== CL_DRIVER
)
1831 /* Walk along the argument string, parsing each word in turn.
1833 arg = [^]{word}[,{arg}]
1834 word = {optimizers|target|warnings|undocumented|
1835 params|common|<language>} */
1845 { "optimizers", CL_OPTIMIZATION
},
1846 { "target", CL_TARGET
},
1847 { "warnings", CL_WARNING
},
1848 { "undocumented", CL_UNDOCUMENTED
},
1849 { "params", CL_PARAMS
},
1850 { "joined", CL_JOINED
},
1851 { "separate", CL_SEPARATE
},
1852 { "common", CL_COMMON
},
1855 unsigned int *pflags
;
1857 unsigned int lang_flag
, specific_flag
;
1866 error_at (loc
, "missing argument to %qs", "--help=^");
1869 pflags
= &exclude_flags
;
1872 pflags
= &include_flags
;
1874 comma
= strchr (a
, ',');
1885 /* Check to see if the string matches an option class name. */
1886 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
1887 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
1889 specific_flag
= specifics
[i
].flag
;
1893 /* Check to see if the string matches a language name.
1894 Note - we rely upon the alpha-sorted nature of the entries in
1895 the lang_names array, specifically that shorter names appear
1896 before their longer variants. (i.e. C before C++). That way
1897 when we are attempting to match --help=c for example we will
1898 match with C first and not C++. */
1899 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
1900 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
1902 lang_flag
= 1U << i
;
1906 if (specific_flag
!= 0)
1909 *pflags
|= specific_flag
;
1912 /* The option's argument matches both the start of a
1913 language name and the start of an option class name.
1914 We have a special case for when the user has
1915 specified "--help=c", but otherwise we have to issue
1917 if (strncasecmp (a
, "c", len
) == 0)
1918 *pflags
|= lang_flag
;
1921 "--help argument %q.*s is ambiguous, "
1922 "please be more specific",
1926 else if (lang_flag
!= 0)
1927 *pflags
|= lang_flag
;
1930 "unrecognized argument to --help= option: %q.*s",
1940 target_option_override_hook ();
1941 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
1944 opts
->x_exit_after_options
= true;
1949 if (lang_mask
== CL_DRIVER
)
1952 opts
->x_exit_after_options
= true;
1955 case OPT_fsanitize_
:
1956 opts
->x_flag_sanitize
1957 = parse_sanitizer_options (arg
, loc
, code
,
1958 opts
->x_flag_sanitize
, value
, true);
1960 /* Kernel ASan implies normal ASan but does not yet support
1962 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
1964 maybe_set_param_value (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD
,
1965 0, opts
->x_param_values
,
1966 opts_set
->x_param_values
);
1967 maybe_set_param_value (PARAM_ASAN_GLOBALS
, 0, opts
->x_param_values
,
1968 opts_set
->x_param_values
);
1969 maybe_set_param_value (PARAM_ASAN_STACK
, 0, opts
->x_param_values
,
1970 opts_set
->x_param_values
);
1971 maybe_set_param_value (PARAM_ASAN_PROTECT_ALLOCAS
, 0,
1972 opts
->x_param_values
,
1973 opts_set
->x_param_values
);
1974 maybe_set_param_value (PARAM_ASAN_USE_AFTER_RETURN
, 0,
1975 opts
->x_param_values
,
1976 opts_set
->x_param_values
);
1980 case OPT_fsanitize_recover_
:
1981 opts
->x_flag_sanitize_recover
1982 = parse_sanitizer_options (arg
, loc
, code
,
1983 opts
->x_flag_sanitize_recover
, value
, true);
1986 case OPT_fasan_shadow_offset_
:
1990 case OPT_fsanitize_address_use_after_scope
:
1991 opts
->x_flag_sanitize_address_use_after_scope
= value
;
1994 case OPT_fsanitize_recover
:
1996 opts
->x_flag_sanitize_recover
1997 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)
1998 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2000 opts
->x_flag_sanitize_recover
2001 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2004 case OPT_fsanitize_coverage_
:
2005 opts
->x_flag_sanitize_coverage
2006 = parse_sanitizer_options (arg
, loc
, code
,
2007 opts
->x_flag_sanitize_coverage
, value
, true);
2014 /* Currently handled in a prescan. */
2018 dc
->warning_as_error_requested
= value
;
2022 if (lang_mask
== CL_DRIVER
)
2025 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
2026 opts
, opts_set
, loc
, dc
);
2029 case OPT_Wlarger_than_
:
2030 opts
->x_larger_than_size
= value
;
2031 opts
->x_warn_larger_than
= value
!= -1;
2034 case OPT_Wfatal_errors
:
2035 dc
->fatal_errors
= value
;
2038 case OPT_Wframe_larger_than_
:
2039 opts
->x_frame_larger_than_size
= value
;
2040 opts
->x_warn_frame_larger_than
= value
!= -1;
2043 case OPT_Wstack_usage_
:
2044 opts
->x_warn_stack_usage
= value
;
2045 opts
->x_flag_stack_usage_info
= value
!= -1;
2048 case OPT_Wstrict_aliasing
:
2049 set_Wstrict_aliasing (opts
, value
);
2052 case OPT_Wstrict_overflow
:
2053 opts
->x_warn_strict_overflow
= (value
2054 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2058 case OPT_Wsystem_headers
:
2059 dc
->dc_warn_system_headers
= value
;
2063 opts
->x_flag_gen_aux_info
= 1;
2066 case OPT_auxbase_strip
:
2068 char *tmp
= xstrdup (arg
);
2069 strip_off_ending (tmp
, strlen (tmp
));
2071 opts
->x_aux_base_name
= tmp
;
2078 decode_d_option (arg
, opts
, loc
, dc
);
2081 case OPT_fcall_used_
:
2082 case OPT_fcall_saved_
:
2090 case OPT_fdbg_cnt_list
:
2092 opts
->x_exit_after_options
= true;
2095 case OPT_fdebug_prefix_map_
:
2099 case OPT_fdiagnostics_show_location_
:
2100 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2103 case OPT_fdiagnostics_show_caret
:
2104 dc
->show_caret
= value
;
2107 case OPT_fdiagnostics_color_
:
2108 diagnostic_color_init (dc
, value
);
2111 case OPT_fdiagnostics_parseable_fixits
:
2112 dc
->parseable_fixits_p
= value
;
2115 case OPT_fdiagnostics_show_option
:
2116 dc
->show_option_requested
= value
;
2123 case OPT_ffast_math
:
2124 set_fast_math_flags (opts
, value
);
2127 case OPT_funsafe_math_optimizations
:
2128 set_unsafe_math_optimizations_flags (opts
, value
);
2135 case OPT_finline_limit_
:
2136 set_param_value ("max-inline-insns-single", value
/ 2,
2137 opts
->x_param_values
, opts_set
->x_param_values
);
2138 set_param_value ("max-inline-insns-auto", value
/ 2,
2139 opts
->x_param_values
, opts_set
->x_param_values
);
2142 case OPT_finstrument_functions_exclude_function_list_
:
2143 add_comma_separated_to_vector
2144 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2147 case OPT_finstrument_functions_exclude_file_list_
:
2148 add_comma_separated_to_vector
2149 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2152 case OPT_fmessage_length_
:
2153 pp_set_line_maximum_length (dc
->printer
, value
);
2154 diagnostic_set_caret_max_width (dc
, value
);
2158 case OPT_fopt_info_
:
2164 const char *p
= arg
;
2165 opts
->x_flag_disable_hsa
= true;
2168 const char *comma
= strchr (p
, ',');
2170 if ((strncmp (p
, "disable", 7) == 0)
2171 && (p
[7] == ',' || p
[7] == '\0'))
2173 opts
->x_flag_disable_hsa
= true;
2177 if ((strncmp (p
, "hsa", 3) == 0)
2178 && (p
[3] == ',' || p
[3] == '\0'))
2181 opts
->x_flag_disable_hsa
= false;
2183 sorry ("HSA has not been enabled during configuration");
2193 #ifndef ACCEL_COMPILER
2194 case OPT_foffload_abi_
:
2195 error_at (loc
, "%<-foffload-abi%> option can be specified only for "
2196 "offload compiler");
2200 case OPT_fpack_struct_
:
2201 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2203 "structure alignment must be a small power of two, not %d",
2206 opts
->x_initial_max_fld_align
= value
;
2210 case OPT_fplugin_arg_
:
2214 case OPT_fprofile_use_
:
2215 opts
->x_profile_data_prefix
= xstrdup (arg
);
2216 opts
->x_flag_profile_use
= true;
2218 /* No break here - do -fprofile-use processing. */
2220 case OPT_fprofile_use
:
2221 enable_fdo_optimizations (opts
, opts_set
, value
);
2222 if (!opts_set
->x_flag_profile_reorder_functions
)
2223 opts
->x_flag_profile_reorder_functions
= value
;
2224 /* Indirect call profiling should do all useful transformations
2225 speculative devirtualization does. */
2226 if (!opts_set
->x_flag_devirtualize_speculatively
2227 && opts
->x_flag_value_profile_transformations
)
2228 opts
->x_flag_devirtualize_speculatively
= false;
2231 case OPT_fauto_profile_
:
2232 opts
->x_auto_profile_file
= xstrdup (arg
);
2233 opts
->x_flag_auto_profile
= true;
2235 /* No break here - do -fauto-profile processing. */
2237 case OPT_fauto_profile
:
2238 enable_fdo_optimizations (opts
, opts_set
, value
);
2239 if (!opts_set
->x_flag_profile_correction
)
2240 opts
->x_flag_profile_correction
= value
;
2241 maybe_set_param_value (
2242 PARAM_EARLY_INLINER_MAX_ITERATIONS
, 10,
2243 opts
->x_param_values
, opts_set
->x_param_values
);
2246 case OPT_fprofile_generate_
:
2247 opts
->x_profile_data_prefix
= xstrdup (arg
);
2249 /* No break here - do -fprofile-generate processing. */
2251 case OPT_fprofile_generate
:
2252 if (!opts_set
->x_profile_arc_flag
)
2253 opts
->x_profile_arc_flag
= value
;
2254 if (!opts_set
->x_flag_profile_values
)
2255 opts
->x_flag_profile_values
= value
;
2256 if (!opts_set
->x_flag_inline_functions
)
2257 opts
->x_flag_inline_functions
= value
;
2258 if (!opts_set
->x_flag_ipa_bit_cp
)
2259 opts
->x_flag_ipa_bit_cp
= value
;
2260 /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
2261 quadratic. Disable the pass until better memory representation
2263 if (!opts_set
->x_flag_ipa_reference
)
2264 opts
->x_flag_ipa_reference
= false;
2267 case OPT_fpatchable_function_entry_
:
2269 char *patch_area_arg
= xstrdup (arg
);
2270 char *comma
= strchr (patch_area_arg
, ',');
2274 function_entry_patch_area_size
=
2275 integral_argument (patch_area_arg
);
2276 function_entry_patch_area_start
=
2277 integral_argument (comma
+ 1);
2281 function_entry_patch_area_size
=
2282 integral_argument (patch_area_arg
);
2283 function_entry_patch_area_start
= 0;
2285 if (function_entry_patch_area_size
< 0
2286 || function_entry_patch_area_start
< 0
2287 || function_entry_patch_area_size
2288 < function_entry_patch_area_start
)
2289 error ("invalid arguments for %<-fpatchable_function_entry%>");
2290 free (patch_area_arg
);
2294 case OPT_ftree_vectorize
:
2295 /* Automatically sets -ftree-loop-vectorize and
2296 -ftree-slp-vectorize. Nothing more to do here. */
2298 case OPT_fshow_column
:
2299 dc
->show_column
= value
;
2302 case OPT_frandom_seed
:
2303 /* The real switch is -fno-random-seed. */
2309 case OPT_frandom_seed_
:
2313 case OPT_fsched_verbose_
:
2314 #ifdef INSN_SCHEDULING
2315 /* Handled with Var in common.opt. */
2321 case OPT_fsched_stalled_insns_
:
2322 opts
->x_flag_sched_stalled_insns
= value
;
2323 if (opts
->x_flag_sched_stalled_insns
== 0)
2324 opts
->x_flag_sched_stalled_insns
= -1;
2327 case OPT_fsched_stalled_insns_dep_
:
2328 opts
->x_flag_sched_stalled_insns_dep
= value
;
2331 case OPT_fstack_check_
:
2332 if (!strcmp (arg
, "no"))
2333 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
2334 else if (!strcmp (arg
, "generic"))
2335 /* This is the old stack checking method. */
2336 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2337 ? FULL_BUILTIN_STACK_CHECK
2338 : GENERIC_STACK_CHECK
;
2339 else if (!strcmp (arg
, "specific"))
2340 /* This is the new stack checking method. */
2341 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2342 ? FULL_BUILTIN_STACK_CHECK
2343 : STACK_CHECK_STATIC_BUILTIN
2344 ? STATIC_BUILTIN_STACK_CHECK
2345 : GENERIC_STACK_CHECK
;
2347 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
2350 case OPT_fstack_limit
:
2351 /* The real switch is -fno-stack-limit. */
2357 case OPT_fstack_limit_register_
:
2358 case OPT_fstack_limit_symbol_
:
2362 case OPT_fstack_usage
:
2363 opts
->x_flag_stack_usage
= value
;
2364 opts
->x_flag_stack_usage_info
= value
!= 0;
2368 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
2373 if (arg
&& strlen (arg
) != 0)
2375 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
2376 "use %<-gdwarf-%s%> for DWARF version "
2377 "or %<-gdwarf -g%s%> for debug level", arg
, arg
, arg
);
2381 value
= opts
->x_dwarf_version
;
2385 if (value
< 2 || value
> 5)
2386 error_at (loc
, "dwarf version %d is not supported", value
);
2388 opts
->x_dwarf_version
= value
;
2389 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
2392 case OPT_gsplit_dwarf
:
2393 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, "", opts
, opts_set
,
2398 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
2403 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
, opts
, opts_set
,
2408 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2413 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
, opts
, opts_set
,
2419 /* Handled completely via specs. */
2422 case OPT_pedantic_errors
:
2423 dc
->pedantic_errors
= 1;
2424 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
2426 handlers
, opts
, opts_set
,
2431 opts
->x_flag_lto
= value
? "" : NULL
;
2435 dc
->dc_inhibit_warnings
= true;
2438 case OPT_fmax_errors_
:
2439 dc
->max_errors
= value
;
2442 case OPT_fuse_ld_bfd
:
2443 case OPT_fuse_ld_gold
:
2444 case OPT_fuse_linker_plugin
:
2445 /* No-op. Used by the driver and passed to us because it starts with f.*/
2450 opts
->x_flag_trapv
= 0;
2455 opts
->x_flag_wrapv
= 0;
2459 opts
->x_flag_ipa_icf_functions
= value
;
2460 opts
->x_flag_ipa_icf_variables
= value
;
2464 /* If the flag was handled in a standard way, assume the lack of
2465 processing here is intentional. */
2466 gcc_assert (option_flag_var (scode
, opts
));
2470 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
2475 /* Handle --param NAME=VALUE. */
2477 handle_param (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2478 location_t loc
, const char *carg
)
2483 arg
= xstrdup (carg
);
2484 equal
= strchr (arg
, '=');
2486 error_at (loc
, "%s: --param arguments should be of the form NAME=VALUE",
2492 enum compiler_param index
;
2493 if (!find_param (arg
, &index
))
2495 const char *suggestion
= find_param_fuzzy (arg
);
2497 error_at (loc
, "invalid --param name %qs; did you mean %qs?",
2500 error_at (loc
, "invalid --param name %qs", arg
);
2504 if (!param_string_value_p (index
, equal
+ 1, &value
))
2505 value
= integral_argument (equal
+ 1);
2508 error_at (loc
, "invalid --param value %qs", equal
+ 1);
2510 set_param_value (arg
, value
,
2511 opts
->x_param_values
, opts_set
->x_param_values
);
2518 /* Used to set the level of strict aliasing warnings in OPTS,
2519 when no level is specified (i.e., when -Wstrict-aliasing, and not
2520 -Wstrict-aliasing=level was given).
2521 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2522 and 0 otherwise. After calling this function, wstrict_aliasing will be
2523 set to the default value of -Wstrict_aliasing=level, currently 3. */
2525 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
2527 gcc_assert (onoff
== 0 || onoff
== 1);
2529 opts
->x_warn_strict_aliasing
= 3;
2531 opts
->x_warn_strict_aliasing
= 0;
2534 /* The following routines are useful in setting all the flags that
2535 -ffast-math and -fno-fast-math imply. */
2537 set_fast_math_flags (struct gcc_options
*opts
, int set
)
2539 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
2541 opts
->x_flag_unsafe_math_optimizations
= set
;
2542 set_unsafe_math_optimizations_flags (opts
, set
);
2544 if (!opts
->frontend_set_flag_finite_math_only
)
2545 opts
->x_flag_finite_math_only
= set
;
2546 if (!opts
->frontend_set_flag_errno_math
)
2547 opts
->x_flag_errno_math
= !set
;
2550 if (opts
->frontend_set_flag_excess_precision_cmdline
2551 == EXCESS_PRECISION_DEFAULT
)
2552 opts
->x_flag_excess_precision_cmdline
2553 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
2554 if (!opts
->frontend_set_flag_signaling_nans
)
2555 opts
->x_flag_signaling_nans
= 0;
2556 if (!opts
->frontend_set_flag_rounding_math
)
2557 opts
->x_flag_rounding_math
= 0;
2558 if (!opts
->frontend_set_flag_cx_limited_range
)
2559 opts
->x_flag_cx_limited_range
= 1;
2563 /* When -funsafe-math-optimizations is set the following
2564 flags are set as well. */
2566 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
2568 if (!opts
->frontend_set_flag_trapping_math
)
2569 opts
->x_flag_trapping_math
= !set
;
2570 if (!opts
->frontend_set_flag_signed_zeros
)
2571 opts
->x_flag_signed_zeros
= !set
;
2572 if (!opts
->frontend_set_flag_associative_math
)
2573 opts
->x_flag_associative_math
= set
;
2574 if (!opts
->frontend_set_flag_reciprocal_math
)
2575 opts
->x_flag_reciprocal_math
= set
;
2578 /* Return true iff flags in OPTS are set as if -ffast-math. */
2580 fast_math_flags_set_p (const struct gcc_options
*opts
)
2582 return (!opts
->x_flag_trapping_math
2583 && opts
->x_flag_unsafe_math_optimizations
2584 && opts
->x_flag_finite_math_only
2585 && !opts
->x_flag_signed_zeros
2586 && !opts
->x_flag_errno_math
2587 && opts
->x_flag_excess_precision_cmdline
2588 == EXCESS_PRECISION_FAST
);
2591 /* Return true iff flags are set as if -ffast-math but using the flags stored
2592 in the struct cl_optimization structure. */
2594 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
2596 return (!opt
->x_flag_trapping_math
2597 && opt
->x_flag_unsafe_math_optimizations
2598 && opt
->x_flag_finite_math_only
2599 && !opt
->x_flag_signed_zeros
2600 && !opt
->x_flag_errno_math
);
2603 /* Handle a debug output -g switch for options OPTS
2604 (OPTS_SET->x_write_symbols storing whether a debug type was passed
2605 explicitly), location LOC. EXTENDED is true or false to support
2606 extended output (2 is special and means "-ggdb" was given). */
2608 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
,
2609 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2612 opts
->x_use_gnu_debug_info_extensions
= extended
;
2614 if (type
== NO_DEBUG
)
2616 if (opts
->x_write_symbols
== NO_DEBUG
)
2618 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
2622 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
2623 opts
->x_write_symbols
= DWARF2_DEBUG
;
2624 #elif defined DBX_DEBUGGING_INFO
2625 opts
->x_write_symbols
= DBX_DEBUG
;
2629 if (opts
->x_write_symbols
== NO_DEBUG
)
2630 warning_at (loc
, 0, "target system does not support debug output");
2635 /* Does it conflict with an already selected type? */
2636 if (opts_set
->x_write_symbols
!= NO_DEBUG
2637 && opts
->x_write_symbols
!= NO_DEBUG
2638 && type
!= opts
->x_write_symbols
)
2639 error_at (loc
, "debug format %qs conflicts with prior selection",
2640 debug_type_names
[type
]);
2641 opts
->x_write_symbols
= type
;
2642 opts_set
->x_write_symbols
= type
;
2645 /* A debug flag without a level defaults to level 2.
2646 If off or at level 1, set it to level 2, but if already
2647 at level 3, don't lower it. */
2650 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
2651 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
2655 int argval
= integral_argument (arg
);
2657 error_at (loc
, "unrecognized debug output level %qs", arg
);
2658 else if (argval
> 3)
2659 error_at (loc
, "debug output level %qs is too high", arg
);
2661 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
2665 /* Arrange to dump core on error for diagnostic context DC. (The
2666 regular error message is still printed first, except in the case of
2670 setup_core_dumping (diagnostic_context
*dc
)
2673 signal (SIGABRT
, SIG_DFL
);
2675 #if defined(HAVE_SETRLIMIT)
2678 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
2679 fatal_error (input_location
, "getting core file size maximum limit: %m");
2680 rlim
.rlim_cur
= rlim
.rlim_max
;
2681 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
2682 fatal_error (input_location
,
2683 "setting core file size limit to maximum: %m");
2686 diagnostic_abort_on_error (dc
);
2689 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
2690 diagnostic context DC. */
2693 decode_d_option (const char *arg
, struct gcc_options
*opts
,
2694 location_t loc
, diagnostic_context
*dc
)
2702 opts
->x_flag_debug_asm
= 1;
2705 opts
->x_flag_print_asm_name
= 1;
2708 opts
->x_flag_dump_rtl_in_asm
= 1;
2709 opts
->x_flag_print_asm_name
= 1;
2712 opts
->x_rtl_dump_and_exit
= 1;
2714 case 'D': /* These are handled by the preprocessor. */
2721 setup_core_dumping (dc
);
2724 opts
->x_flag_dump_all_passed
= true;
2728 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
2733 /* Enable (or disable if VALUE is 0) a warning option ARG (language
2734 mask LANG_MASK, option handlers HANDLERS) as an error for option
2735 structures OPTS and OPTS_SET, diagnostic context DC (possibly
2736 NULL), location LOC. This is used by -Werror=. */
2739 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
2740 const struct cl_option_handlers
*handlers
,
2741 struct gcc_options
*opts
,
2742 struct gcc_options
*opts_set
,
2743 location_t loc
, diagnostic_context
*dc
)
2748 new_option
= XNEWVEC (char, strlen (arg
) + 2);
2749 new_option
[0] = 'W';
2750 strcpy (new_option
+ 1, arg
);
2751 option_index
= find_opt (new_option
, lang_mask
);
2752 if (option_index
== OPT_SPECIAL_unknown
)
2753 error_at (loc
, "-Werror=%s: no option -%s", arg
, new_option
);
2754 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
2755 error_at (loc
, "-Werror=%s: -%s is not an option that controls warnings",
2759 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
2760 const char *arg
= NULL
;
2762 if (cl_options
[option_index
].flags
& CL_JOINED
)
2763 arg
= new_option
+ cl_options
[option_index
].opt_len
;
2764 control_warning_option (option_index
, (int) kind
, arg
, value
,
2766 handlers
, opts
, opts_set
, dc
);
2771 /* Return malloced memory for the name of the option OPTION_INDEX
2772 which enabled a diagnostic (context CONTEXT), originally of type
2773 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2777 option_name (diagnostic_context
*context
, int option_index
,
2778 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
2782 /* A warning classified as an error. */
2783 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
2784 && diag_kind
== DK_ERROR
)
2785 return concat (cl_options
[OPT_Werror_
].opt_text
,
2786 /* Skip over "-W". */
2787 cl_options
[option_index
].opt_text
+ 2,
2789 /* A warning with option. */
2791 return xstrdup (cl_options
[option_index
].opt_text
);
2793 /* A warning without option classified as an error. */
2794 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
2795 || diag_kind
== DK_WARNING
)
2796 && context
->warning_as_error_requested
)
2797 return xstrdup (cl_options
[OPT_Werror
].opt_text
);