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", "coff", "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 five characters. (Java uses ".class".) */
145 strip_off_ending (char *name
, int len
)
148 for (i
= 2; i
< 6 && 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
)
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 },
480 /* -O2 optimizations. */
481 { OPT_LEVELS_2_PLUS
, OPT_finline_small_functions
, NULL
, 1 },
482 { OPT_LEVELS_2_PLUS
, OPT_findirect_inlining
, NULL
, 1 },
483 { OPT_LEVELS_2_PLUS
, OPT_fpartial_inlining
, NULL
, 1 },
484 { OPT_LEVELS_2_PLUS
, OPT_fthread_jumps
, NULL
, 1 },
485 { OPT_LEVELS_2_PLUS
, OPT_fcrossjumping
, NULL
, 1 },
486 { OPT_LEVELS_2_PLUS
, OPT_foptimize_sibling_calls
, NULL
, 1 },
487 { OPT_LEVELS_2_PLUS
, OPT_fcse_follow_jumps
, NULL
, 1 },
488 { OPT_LEVELS_2_PLUS
, OPT_fgcse
, NULL
, 1 },
489 { OPT_LEVELS_2_PLUS
, OPT_fexpensive_optimizations
, NULL
, 1 },
490 { OPT_LEVELS_2_PLUS
, OPT_frerun_cse_after_loop
, NULL
, 1 },
491 { OPT_LEVELS_2_PLUS
, OPT_fcaller_saves
, NULL
, 1 },
492 { OPT_LEVELS_2_PLUS
, OPT_fpeephole2
, NULL
, 1 },
493 #ifdef INSN_SCHEDULING
494 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
495 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_fschedule_insns
, NULL
, 1 },
496 { OPT_LEVELS_2_PLUS
, OPT_fschedule_insns2
, NULL
, 1 },
498 { OPT_LEVELS_2_PLUS
, OPT_fstrict_aliasing
, NULL
, 1 },
499 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_freorder_blocks_algorithm_
, NULL
,
500 REORDER_BLOCKS_ALGORITHM_STC
},
501 { OPT_LEVELS_2_PLUS
, OPT_freorder_functions
, NULL
, 1 },
502 { OPT_LEVELS_2_PLUS
, OPT_ftree_vrp
, NULL
, 1 },
503 { OPT_LEVELS_2_PLUS
, OPT_fcode_hoisting
, NULL
, 1 },
504 { OPT_LEVELS_2_PLUS
, OPT_ftree_pre
, NULL
, 1 },
505 { OPT_LEVELS_2_PLUS
, OPT_ftree_switch_conversion
, NULL
, 1 },
506 { OPT_LEVELS_2_PLUS
, OPT_fipa_cp
, NULL
, 1 },
507 { OPT_LEVELS_2_PLUS
, OPT_fipa_bit_cp
, NULL
, 1 },
508 { OPT_LEVELS_2_PLUS
, OPT_fipa_vrp
, NULL
, 1 },
509 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize
, NULL
, 1 },
510 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize_speculatively
, NULL
, 1 },
511 { OPT_LEVELS_2_PLUS
, OPT_fipa_sra
, NULL
, 1 },
512 { OPT_LEVELS_2_PLUS
, OPT_falign_loops
, NULL
, 1 },
513 { OPT_LEVELS_2_PLUS
, OPT_falign_jumps
, NULL
, 1 },
514 { OPT_LEVELS_2_PLUS
, OPT_falign_labels
, NULL
, 1 },
515 { OPT_LEVELS_2_PLUS
, OPT_falign_functions
, NULL
, 1 },
516 { OPT_LEVELS_2_PLUS
, OPT_ftree_tail_merge
, NULL
, 1 },
517 { OPT_LEVELS_2_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_CHEAP
},
518 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_foptimize_strlen
, NULL
, 1 },
519 { OPT_LEVELS_2_PLUS
, OPT_fhoist_adjacent_loads
, NULL
, 1 },
520 { OPT_LEVELS_2_PLUS
, OPT_fipa_icf
, NULL
, 1 },
521 { OPT_LEVELS_2_PLUS
, OPT_fisolate_erroneous_paths_dereference
, NULL
, 1 },
522 { OPT_LEVELS_2_PLUS
, OPT_fipa_ra
, NULL
, 1 },
523 { OPT_LEVELS_2_PLUS
, OPT_flra_remat
, NULL
, 1 },
524 { OPT_LEVELS_2_PLUS
, OPT_fstore_merging
, NULL
, 1 },
526 /* -O3 optimizations. */
527 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribute_patterns
, NULL
, 1 },
528 { OPT_LEVELS_3_PLUS
, OPT_fpredictive_commoning
, NULL
, 1 },
529 { OPT_LEVELS_3_PLUS
, OPT_fsplit_paths
, NULL
, 1 },
530 /* Inlining of functions reducing size is a good idea with -Os
531 regardless of them being declared inline. */
532 { OPT_LEVELS_3_PLUS_AND_SIZE
, OPT_finline_functions
, NULL
, 1 },
533 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_finline_functions_called_once
, NULL
, 1 },
534 { OPT_LEVELS_3_PLUS
, OPT_fsplit_loops
, NULL
, 1 },
535 { OPT_LEVELS_3_PLUS
, OPT_funswitch_loops
, NULL
, 1 },
536 { OPT_LEVELS_3_PLUS
, OPT_fgcse_after_reload
, NULL
, 1 },
537 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_vectorize
, NULL
, 1 },
538 { OPT_LEVELS_3_PLUS
, OPT_ftree_slp_vectorize
, NULL
, 1 },
539 { OPT_LEVELS_3_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_DYNAMIC
},
540 { OPT_LEVELS_3_PLUS
, OPT_fipa_cp_clone
, NULL
, 1 },
541 { OPT_LEVELS_3_PLUS
, OPT_ftree_partial_pre
, NULL
, 1 },
542 { OPT_LEVELS_3_PLUS
, OPT_fpeel_loops
, NULL
, 1 },
544 /* -Ofast adds optimizations to -O3. */
545 { OPT_LEVELS_FAST
, OPT_ffast_math
, NULL
, 1 },
547 { OPT_LEVELS_NONE
, 0, NULL
, 0 }
550 /* Default the options in OPTS and OPTS_SET based on the optimization
551 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
553 default_options_optimization (struct gcc_options
*opts
,
554 struct gcc_options
*opts_set
,
555 struct cl_decoded_option
*decoded_options
,
556 unsigned int decoded_options_count
,
558 unsigned int lang_mask
,
559 const struct cl_option_handlers
*handlers
,
560 diagnostic_context
*dc
)
564 bool openacc_mode
= false;
566 /* Scan to see what optimization level has been specified. That will
567 determine the default value of many flags. */
568 for (i
= 1; i
< decoded_options_count
; i
++)
570 struct cl_decoded_option
*opt
= &decoded_options
[i
];
571 switch (opt
->opt_index
)
574 if (*opt
->arg
== '\0')
576 opts
->x_optimize
= 1;
577 opts
->x_optimize_size
= 0;
578 opts
->x_optimize_fast
= 0;
579 opts
->x_optimize_debug
= 0;
583 const int optimize_val
= integral_argument (opt
->arg
);
584 if (optimize_val
== -1)
585 error_at (loc
, "argument to %<-O%> should be a non-negative "
586 "integer, %<g%>, %<s%> or %<fast%>");
589 opts
->x_optimize
= optimize_val
;
590 if ((unsigned int) opts
->x_optimize
> 255)
591 opts
->x_optimize
= 255;
592 opts
->x_optimize_size
= 0;
593 opts
->x_optimize_fast
= 0;
594 opts
->x_optimize_debug
= 0;
600 opts
->x_optimize_size
= 1;
602 /* Optimizing for size forces optimize to be 2. */
603 opts
->x_optimize
= 2;
604 opts
->x_optimize_fast
= 0;
605 opts
->x_optimize_debug
= 0;
609 /* -Ofast only adds flags to -O3. */
610 opts
->x_optimize_size
= 0;
611 opts
->x_optimize
= 3;
612 opts
->x_optimize_fast
= 1;
613 opts
->x_optimize_debug
= 0;
617 /* -Og selects optimization level 1. */
618 opts
->x_optimize_size
= 0;
619 opts
->x_optimize
= 1;
620 opts
->x_optimize_fast
= 0;
621 opts
->x_optimize_debug
= 1;
630 /* Ignore other options in this prescan. */
635 maybe_default_options (opts
, opts_set
, default_options_table
,
636 opts
->x_optimize
, opts
->x_optimize_size
,
637 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
638 lang_mask
, handlers
, loc
, dc
);
640 /* -O2 param settings. */
641 opt2
= (opts
->x_optimize
>= 2);
644 && !opts_set
->x_flag_ipa_pta
)
645 opts
->x_flag_ipa_pta
= true;
647 /* Track fields in field-sensitive alias analysis. */
648 maybe_set_param_value
649 (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
,
650 opt2
? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
),
651 opts
->x_param_values
, opts_set
->x_param_values
);
653 /* For -O1 only do loop invariant motion for very small loops. */
654 maybe_set_param_value
655 (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
,
656 opt2
? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
) : 1000,
657 opts
->x_param_values
, opts_set
->x_param_values
);
659 /* At -Ofast, allow store motion to introduce potential race conditions. */
660 maybe_set_param_value
661 (PARAM_ALLOW_STORE_DATA_RACES
,
662 opts
->x_optimize_fast
? 1
663 : default_param_value (PARAM_ALLOW_STORE_DATA_RACES
),
664 opts
->x_param_values
, opts_set
->x_param_values
);
666 if (opts
->x_optimize_size
)
667 /* We want to crossjump as much as possible. */
668 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
, 1,
669 opts
->x_param_values
, opts_set
->x_param_values
);
671 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
,
672 default_param_value (PARAM_MIN_CROSSJUMP_INSNS
),
673 opts
->x_param_values
, opts_set
->x_param_values
);
675 /* Restrict the amount of work combine does at -Og while retaining
676 most of its useful transforms. */
677 if (opts
->x_optimize_debug
)
678 maybe_set_param_value (PARAM_MAX_COMBINE_INSNS
, 2,
679 opts
->x_param_values
, opts_set
->x_param_values
);
681 /* Allow default optimizations to be specified on a per-machine basis. */
682 maybe_default_options (opts
, opts_set
,
683 targetm_common
.option_optimization_table
,
684 opts
->x_optimize
, opts
->x_optimize_size
,
685 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
686 lang_mask
, handlers
, loc
, dc
);
689 /* After all options at LOC have been read into OPTS and OPTS_SET,
690 finalize settings of those options and diagnose incompatible
693 finish_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
696 enum unwind_info_type ui_except
;
698 if (opts
->x_dump_base_name
699 && ! IS_ABSOLUTE_PATH (opts
->x_dump_base_name
)
700 && ! opts
->x_dump_base_name_prefixed
)
702 /* First try to make OPTS->X_DUMP_BASE_NAME relative to the
703 OPTS->X_DUMP_DIR_NAME directory. Then try to make
704 OPTS->X_DUMP_BASE_NAME relative to the OPTS->X_AUX_BASE_NAME
705 directory, typically the directory to contain the object
707 if (opts
->x_dump_dir_name
)
708 opts
->x_dump_base_name
= opts_concat (opts
->x_dump_dir_name
,
709 opts
->x_dump_base_name
, NULL
);
710 else if (opts
->x_aux_base_name
711 && strcmp (opts
->x_aux_base_name
, HOST_BIT_BUCKET
) != 0)
713 const char *aux_base
;
715 base_of_path (opts
->x_aux_base_name
, &aux_base
);
716 if (opts
->x_aux_base_name
!= aux_base
)
718 int dir_len
= aux_base
- opts
->x_aux_base_name
;
719 char *new_dump_base_name
720 = XOBNEWVEC (&opts_obstack
, char,
721 strlen (opts
->x_dump_base_name
) + dir_len
+ 1);
723 /* Copy directory component from OPTS->X_AUX_BASE_NAME. */
724 memcpy (new_dump_base_name
, opts
->x_aux_base_name
, dir_len
);
725 /* Append existing OPTS->X_DUMP_BASE_NAME. */
726 strcpy (new_dump_base_name
+ dir_len
, opts
->x_dump_base_name
);
727 opts
->x_dump_base_name
= new_dump_base_name
;
730 opts
->x_dump_base_name_prefixed
= true;
733 /* Handle related options for unit-at-a-time, toplevel-reorder, and
735 if (!opts
->x_flag_unit_at_a_time
)
737 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
738 error_at (loc
, "section anchors must be disabled when unit-at-a-time "
740 opts
->x_flag_section_anchors
= 0;
741 if (opts
->x_flag_toplevel_reorder
== 1)
742 error_at (loc
, "toplevel reorder must be disabled when unit-at-a-time "
744 opts
->x_flag_toplevel_reorder
= 0;
747 /* -fself-test depends on the state of the compiler prior to
748 compiling anything. Ideally it should be run on an empty source
749 file. However, in case we get run with actual source, assume
750 -fsyntax-only which will inhibit any compiler initialization
751 which may confuse the self tests. */
752 if (opts
->x_flag_self_test
)
753 opts
->x_flag_syntax_only
= 1;
755 if (opts
->x_flag_tm
&& opts
->x_flag_non_call_exceptions
)
756 sorry ("transactional memory is not supported with non-call exceptions");
758 /* Unless the user has asked for section anchors, we disable toplevel
759 reordering at -O0 to disable transformations that might be surprising
760 to end users and to get -fno-toplevel-reorder tested. */
761 if (!opts
->x_optimize
762 && opts
->x_flag_toplevel_reorder
== 2
763 && !(opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
))
765 opts
->x_flag_toplevel_reorder
= 0;
766 opts
->x_flag_section_anchors
= 0;
768 if (!opts
->x_flag_toplevel_reorder
)
770 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
771 error_at (loc
, "section anchors must be disabled when toplevel reorder"
773 opts
->x_flag_section_anchors
= 0;
776 if (!opts
->x_flag_opts_finished
)
778 /* We initialize opts->x_flag_pie to -1 so that targets can set a
780 if (opts
->x_flag_pie
== -1)
782 /* We initialize opts->x_flag_pic to -1 so that we can tell if
783 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
784 if (opts
->x_flag_pic
== -1)
785 opts
->x_flag_pie
= DEFAULT_FLAG_PIE
;
787 opts
->x_flag_pie
= 0;
789 /* If -fPIE or -fpie is used, turn on PIC. */
790 if (opts
->x_flag_pie
)
791 opts
->x_flag_pic
= opts
->x_flag_pie
;
792 else if (opts
->x_flag_pic
== -1)
793 opts
->x_flag_pic
= 0;
794 if (opts
->x_flag_pic
&& !opts
->x_flag_pie
)
795 opts
->x_flag_shlib
= 1;
796 opts
->x_flag_opts_finished
= true;
799 /* We initialize opts->x_flag_stack_protect to -1 so that targets
800 can set a default value. */
801 if (opts
->x_flag_stack_protect
== -1)
802 opts
->x_flag_stack_protect
= DEFAULT_FLAG_SSP
;
804 if (opts
->x_optimize
== 0)
806 /* Inlining does not work if not optimizing,
807 so force it not to be done. */
808 opts
->x_warn_inline
= 0;
809 opts
->x_flag_no_inline
= 1;
812 /* The optimization to partition hot and cold basic blocks into separate
813 sections of the .o and executable files does not work (currently)
814 with exception handling. This is because there is no support for
815 generating unwind info. If opts->x_flag_exceptions is turned on
816 we need to turn off the partitioning optimization. */
818 ui_except
= targetm_common
.except_unwind_info (opts
);
820 if (opts
->x_flag_exceptions
821 && opts
->x_flag_reorder_blocks_and_partition
822 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
824 if (opts_set
->x_flag_reorder_blocks_and_partition
)
826 "-freorder-blocks-and-partition does not work "
827 "with exceptions on this architecture");
828 opts
->x_flag_reorder_blocks_and_partition
= 0;
829 opts
->x_flag_reorder_blocks
= 1;
832 /* If user requested unwind info, then turn off the partitioning
835 if (opts
->x_flag_unwind_tables
836 && !targetm_common
.unwind_tables_default
837 && opts
->x_flag_reorder_blocks_and_partition
838 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
840 if (opts_set
->x_flag_reorder_blocks_and_partition
)
842 "-freorder-blocks-and-partition does not support "
843 "unwind info on this architecture");
844 opts
->x_flag_reorder_blocks_and_partition
= 0;
845 opts
->x_flag_reorder_blocks
= 1;
848 /* If the target requested unwind info, then turn off the partitioning
849 optimization with a different message. Likewise, if the target does not
850 support named sections. */
852 if (opts
->x_flag_reorder_blocks_and_partition
853 && (!targetm_common
.have_named_sections
854 || (opts
->x_flag_unwind_tables
855 && targetm_common
.unwind_tables_default
856 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
858 if (opts_set
->x_flag_reorder_blocks_and_partition
)
860 "-freorder-blocks-and-partition does not work "
861 "on this architecture");
862 opts
->x_flag_reorder_blocks_and_partition
= 0;
863 opts
->x_flag_reorder_blocks
= 1;
866 if (opts
->x_flag_reorder_blocks_and_partition
867 && !opts_set
->x_flag_reorder_functions
)
868 opts
->x_flag_reorder_functions
= 1;
870 /* Pipelining of outer loops is only possible when general pipelining
871 capabilities are requested. */
872 if (!opts
->x_flag_sel_sched_pipelining
)
873 opts
->x_flag_sel_sched_pipelining_outer_loops
= 0;
875 if (opts
->x_flag_conserve_stack
)
877 maybe_set_param_value (PARAM_LARGE_STACK_FRAME
, 100,
878 opts
->x_param_values
, opts_set
->x_param_values
);
879 maybe_set_param_value (PARAM_STACK_FRAME_GROWTH
, 40,
880 opts
->x_param_values
, opts_set
->x_param_values
);
883 if (opts
->x_flag_lto
)
886 opts
->x_flag_generate_lto
= 1;
888 /* When generating IL, do not operate in whole-program mode.
889 Otherwise, symbols will be privatized too early, causing link
891 opts
->x_flag_whole_program
= 0;
893 error_at (loc
, "LTO support has not been enabled in this configuration");
895 if (!opts
->x_flag_fat_lto_objects
897 || (opts_set
->x_flag_use_linker_plugin
898 && !opts
->x_flag_use_linker_plugin
)))
900 if (opts_set
->x_flag_fat_lto_objects
)
901 error_at (loc
, "-fno-fat-lto-objects are supported only with linker plugin");
902 opts
->x_flag_fat_lto_objects
= 1;
906 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
907 default value if they choose based on other options. */
908 if (opts
->x_flag_split_stack
== -1)
909 opts
->x_flag_split_stack
= 0;
910 else if (opts
->x_flag_split_stack
)
912 if (!targetm_common
.supports_split_stack (true, opts
))
914 error_at (loc
, "%<-fsplit-stack%> is not supported by "
915 "this compiler configuration");
916 opts
->x_flag_split_stack
= 0;
920 /* Tune vectorization related parametees according to cost model. */
921 if (opts
->x_flag_vect_cost_model
== VECT_COST_MODEL_CHEAP
)
923 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS
,
924 6, opts
->x_param_values
, opts_set
->x_param_values
);
925 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS
,
926 0, opts
->x_param_values
, opts_set
->x_param_values
);
927 maybe_set_param_value (PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT
,
928 0, opts
->x_param_values
, opts_set
->x_param_values
);
931 /* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
933 if ((!opts
->x_flag_tree_loop_vectorize
&& !opts
->x_flag_tree_slp_vectorize
)
934 || !opts
->x_flag_tree_loop_if_convert
)
935 maybe_set_param_value (PARAM_MAX_STORES_TO_SINK
, 0,
936 opts
->x_param_values
, opts_set
->x_param_values
);
938 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
939 if (opts
->x_dwarf_split_debug_info
)
940 opts
->x_debug_generate_pub_sections
= 2;
942 /* Userspace and kernel ASan conflict with each other. */
943 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
944 && (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
))
946 "-fsanitize=address is incompatible with "
947 "-fsanitize=kernel-address");
950 if ((opts
->x_flag_sanitize
& SANITIZE_ADDRESS
)
951 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
953 "-fsanitize=address and -fsanitize=kernel-address "
954 "are incompatible with -fsanitize=thread");
956 if ((opts
->x_flag_sanitize
& SANITIZE_LEAK
)
957 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
959 "-fsanitize=leak is incompatible with -fsanitize=thread");
961 /* Check error recovery for -fsanitize-recover option. */
962 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
963 if ((opts
->x_flag_sanitize_recover
& sanitizer_opts
[i
].flag
)
964 && !sanitizer_opts
[i
].can_recover
)
965 error_at (loc
, "-fsanitize-recover=%s is not supported",
966 sanitizer_opts
[i
].name
);
968 /* When instrumenting the pointers, we don't want to remove
969 the null pointer checks. */
970 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
971 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
972 opts
->x_flag_delete_null_pointer_checks
= 0;
974 /* Aggressive compiler optimizations may cause false negatives. */
975 if (opts
->x_flag_sanitize
& ~(SANITIZE_LEAK
| SANITIZE_UNREACHABLE
))
976 opts
->x_flag_aggressive_loop_optimizations
= 0;
978 /* Enable -fsanitize-address-use-after-scope if address sanitizer is
980 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
981 && !opts_set
->x_flag_sanitize_address_use_after_scope
)
982 opts
->x_flag_sanitize_address_use_after_scope
= true;
984 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
986 if (opts
->x_flag_sanitize_address_use_after_scope
)
988 if (opts
->x_flag_stack_reuse
!= SR_NONE
989 && opts_set
->x_flag_stack_reuse
!= SR_NONE
)
991 "-fsanitize-address-use-after-scope requires "
992 "-fstack-reuse=none option");
994 opts
->x_flag_stack_reuse
= SR_NONE
;
998 #define LEFT_COLUMN 27
1000 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1001 followed by word-wrapped HELP in a second column. */
1003 wrap_help (const char *help
,
1005 unsigned int item_width
,
1006 unsigned int columns
)
1008 unsigned int col_width
= LEFT_COLUMN
;
1009 unsigned int remaining
, room
, len
;
1011 remaining
= strlen (help
);
1015 room
= columns
- 3 - MAX (col_width
, item_width
);
1024 for (i
= 0; help
[i
]; i
++)
1026 if (i
>= room
&& len
!= remaining
)
1030 else if ((help
[i
] == '-' || help
[i
] == '/')
1031 && help
[i
+ 1] != ' '
1032 && i
> 0 && ISALPHA (help
[i
- 1]))
1037 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1039 while (help
[len
] == ' ')
1047 /* Print help for a specific front-end, etc. */
1049 print_filtered_help (unsigned int include_flags
,
1050 unsigned int exclude_flags
,
1051 unsigned int any_flags
,
1052 unsigned int columns
,
1053 struct gcc_options
*opts
,
1054 unsigned int lang_mask
)
1059 bool displayed
= false;
1062 if (include_flags
== CL_PARAMS
)
1064 for (i
= 0; i
< LAST_PARAM
; i
++)
1066 const char *param
= compiler_params
[i
].option
;
1068 help
= compiler_params
[i
].help
;
1069 if (help
== NULL
|| *help
== '\0')
1071 if (exclude_flags
& CL_UNDOCUMENTED
)
1073 help
= undocumented_msg
;
1076 /* Get the translation. */
1079 if (!opts
->x_quiet_flag
)
1081 snprintf (new_help
, sizeof (new_help
),
1082 _("default %d minimum %d maximum %d"),
1083 compiler_params
[i
].default_value
,
1084 compiler_params
[i
].min_value
,
1085 compiler_params
[i
].max_value
);
1088 wrap_help (help
, param
, strlen (param
), columns
);
1094 if (!opts
->x_help_printed
)
1095 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1097 if (!opts
->x_help_enum_printed
)
1098 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1100 for (i
= 0; i
< cl_options_count
; i
++)
1102 const struct cl_option
*option
= cl_options
+ i
;
1107 if (include_flags
== 0
1108 || ((option
->flags
& include_flags
) != include_flags
))
1110 if ((option
->flags
& any_flags
) == 0)
1114 /* Skip unwanted switches. */
1115 if ((option
->flags
& exclude_flags
) != 0)
1118 /* The driver currently prints its own help text. */
1119 if ((option
->flags
& CL_DRIVER
) != 0
1120 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1121 | CL_COMMON
| CL_TARGET
)) == 0)
1125 /* Skip switches that have already been printed. */
1126 if (opts
->x_help_printed
[i
])
1129 opts
->x_help_printed
[i
] = true;
1131 help
= option
->help
;
1134 if (exclude_flags
& CL_UNDOCUMENTED
)
1137 help
= undocumented_msg
;
1140 if (option
->alias_target
< N_OPTS
1141 && cl_options
[option
->alias_target
].help
)
1143 if (help
== undocumented_msg
)
1145 /* For undocumented options that are aliases for other options
1146 that are documented, point the reader to the other option in
1147 preference of the former. */
1148 snprintf (new_help
, sizeof new_help
,
1149 _("Same as %s. Use the latter option instead."),
1150 cl_options
[option
->alias_target
].opt_text
);
1154 /* For documented options with aliases, mention the aliased
1155 option's name for reference. */
1156 snprintf (new_help
, sizeof new_help
,
1157 _("%s Same as %s."),
1158 help
, cl_options
[option
->alias_target
].opt_text
);
1164 if (option
->warn_message
)
1166 /* Mention that the use of the option will trigger a warning. */
1167 if (help
== new_help
)
1168 snprintf (new_help
+ strlen (new_help
),
1169 sizeof new_help
- strlen (new_help
),
1170 " %s", _(use_diagnosed_msg
));
1172 snprintf (new_help
, sizeof new_help
,
1173 "%s %s", help
, _(use_diagnosed_msg
));
1178 /* Get the translation. */
1181 /* Find the gap between the name of the
1182 option and its descriptive text. */
1183 tab
= strchr (help
, '\t');
1192 opt
= option
->opt_text
;
1196 /* With the -Q option enabled we change the descriptive text associated
1197 with an option to be an indication of its current setting. */
1198 if (!opts
->x_quiet_flag
)
1200 void *flag_var
= option_flag_var (i
, opts
);
1202 if (len
< (LEFT_COLUMN
+ 2))
1203 strcpy (new_help
, "\t\t");
1205 strcpy (new_help
, "\t");
1207 if (flag_var
!= NULL
1208 && option
->var_type
!= CLVC_DEFER
)
1210 if (option
->flags
& CL_JOINED
)
1212 if (option
->var_type
== CLVC_STRING
)
1214 if (* (const char **) flag_var
!= NULL
)
1215 snprintf (new_help
+ strlen (new_help
),
1216 sizeof (new_help
) - strlen (new_help
),
1217 "%s", * (const char **) flag_var
);
1219 else if (option
->var_type
== CLVC_ENUM
)
1221 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1223 const char *arg
= NULL
;
1225 value
= e
->get (flag_var
);
1226 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1228 arg
= _("[default]");
1229 snprintf (new_help
+ strlen (new_help
),
1230 sizeof (new_help
) - strlen (new_help
),
1234 sprintf (new_help
+ strlen (new_help
),
1235 "%d", * (int *) flag_var
);
1238 strcat (new_help
, option_enabled (i
, opts
)
1239 ? _("[enabled]") : _("[disabled]"));
1245 wrap_help (help
, opt
, len
, columns
);
1248 if (option
->var_type
== CLVC_ENUM
1249 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1250 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1255 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1258 printf (_(" No options with the desired characteristics were found\n"));
1263 /* PR 31349: Tell the user how to see all of the
1264 options supported by a specific front end. */
1265 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1266 if ((1U << i
) & langs
)
1267 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1268 lang_names
[i
], lang_names
[i
]);
1272 else if (! displayed
)
1273 printf (_(" All options with the desired characteristics have already been displayed\n"));
1277 /* Print details of enumerated option arguments, if those
1278 enumerations have help text headings provided. If no help text
1279 is provided, presume that the possible values are listed in the
1280 help text for the relevant options. */
1281 for (i
= 0; i
< cl_enums_count
; i
++)
1283 unsigned int j
, pos
;
1285 if (opts
->x_help_enum_printed
[i
] != 1)
1287 if (cl_enums
[i
].help
== NULL
)
1289 printf (" %s\n ", _(cl_enums
[i
].help
));
1291 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1293 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1295 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1297 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1307 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1312 opts
->x_help_enum_printed
[i
] = 2;
1316 /* Display help for a specified type of option.
1317 The options must have ALL of the INCLUDE_FLAGS set
1318 ANY of the flags in the ANY_FLAGS set
1319 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1320 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1322 print_specific_help (unsigned int include_flags
,
1323 unsigned int exclude_flags
,
1324 unsigned int any_flags
,
1325 struct gcc_options
*opts
,
1326 unsigned int lang_mask
)
1328 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1329 const char * description
= NULL
;
1330 const char * descrip_extra
= "";
1334 /* Sanity check: Make sure that we do not have more
1335 languages than we have bits available to enumerate them. */
1336 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1338 /* If we have not done so already, obtain
1339 the desired maximum width of the output. */
1340 if (opts
->x_help_columns
== 0)
1342 opts
->x_help_columns
= get_terminal_width ();
1343 if (opts
->x_help_columns
== INT_MAX
)
1344 /* Use a reasonable default. */
1345 opts
->x_help_columns
= 80;
1348 /* Decide upon the title for the options that we are going to display. */
1349 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1351 switch (flag
& include_flags
)
1358 description
= _("The following options are target specific");
1361 description
= _("The following options control compiler warning messages");
1363 case CL_OPTIMIZATION
:
1364 description
= _("The following options control optimizations");
1367 description
= _("The following options are language-independent");
1370 description
= _("The --param option recognizes the following as parameters");
1373 if (i
>= cl_lang_count
)
1375 if (exclude_flags
& all_langs_mask
)
1376 description
= _("The following options are specific to just the language ");
1378 description
= _("The following options are supported by the language ");
1379 descrip_extra
= lang_names
[i
];
1384 if (description
== NULL
)
1388 if (include_flags
& CL_UNDOCUMENTED
)
1389 description
= _("The following options are not documented");
1390 else if (include_flags
& CL_SEPARATE
)
1391 description
= _("The following options take separate arguments");
1392 else if (include_flags
& CL_JOINED
)
1393 description
= _("The following options take joined arguments");
1396 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1403 if (any_flags
& all_langs_mask
)
1404 description
= _("The following options are language-related");
1406 description
= _("The following options are language-independent");
1410 printf ("%s%s:\n", description
, descrip_extra
);
1411 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
1412 opts
->x_help_columns
, opts
, lang_mask
);
1415 /* Enable FDO-related flags. */
1418 enable_fdo_optimizations (struct gcc_options
*opts
,
1419 struct gcc_options
*opts_set
,
1422 if (!opts_set
->x_flag_branch_probabilities
)
1423 opts
->x_flag_branch_probabilities
= value
;
1424 if (!opts_set
->x_flag_profile_values
)
1425 opts
->x_flag_profile_values
= value
;
1426 if (!opts_set
->x_flag_unroll_loops
)
1427 opts
->x_flag_unroll_loops
= value
;
1428 if (!opts_set
->x_flag_peel_loops
)
1429 opts
->x_flag_peel_loops
= value
;
1430 if (!opts_set
->x_flag_tracer
)
1431 opts
->x_flag_tracer
= value
;
1432 if (!opts_set
->x_flag_value_profile_transformations
)
1433 opts
->x_flag_value_profile_transformations
= value
;
1434 if (!opts_set
->x_flag_inline_functions
)
1435 opts
->x_flag_inline_functions
= value
;
1436 if (!opts_set
->x_flag_ipa_cp
)
1437 opts
->x_flag_ipa_cp
= value
;
1438 if (!opts_set
->x_flag_ipa_cp_clone
1439 && value
&& opts
->x_flag_ipa_cp
)
1440 opts
->x_flag_ipa_cp_clone
= value
;
1441 if (!opts_set
->x_flag_ipa_bit_cp
1442 && value
&& opts
->x_flag_ipa_cp
)
1443 opts
->x_flag_ipa_bit_cp
= value
;
1444 if (!opts_set
->x_flag_predictive_commoning
)
1445 opts
->x_flag_predictive_commoning
= value
;
1446 if (!opts_set
->x_flag_split_loops
)
1447 opts
->x_flag_split_loops
= value
;
1448 if (!opts_set
->x_flag_unswitch_loops
)
1449 opts
->x_flag_unswitch_loops
= value
;
1450 if (!opts_set
->x_flag_gcse_after_reload
)
1451 opts
->x_flag_gcse_after_reload
= value
;
1452 if (!opts_set
->x_flag_tree_loop_vectorize
1453 && !opts_set
->x_flag_tree_vectorize
)
1454 opts
->x_flag_tree_loop_vectorize
= value
;
1455 if (!opts_set
->x_flag_tree_slp_vectorize
1456 && !opts_set
->x_flag_tree_vectorize
)
1457 opts
->x_flag_tree_slp_vectorize
= value
;
1458 if (!opts_set
->x_flag_vect_cost_model
)
1459 opts
->x_flag_vect_cost_model
= VECT_COST_MODEL_DYNAMIC
;
1460 if (!opts_set
->x_flag_tree_loop_distribute_patterns
)
1461 opts
->x_flag_tree_loop_distribute_patterns
= value
;
1464 /* -f{,no-}sanitize{,-recover}= suboptions. */
1465 const struct sanitizer_opts_s sanitizer_opts
[] =
1467 #define SANITIZER_OPT(name, flags, recover) \
1468 { #name, flags, sizeof #name - 1, recover }
1469 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true),
1470 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
1472 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false),
1473 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false),
1474 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true),
1475 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true),
1476 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true),
1477 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true),
1478 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true),
1479 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false),
1480 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true),
1481 SANITIZER_OPT (return, SANITIZE_RETURN
, false),
1482 SANITIZER_OPT (null
, SANITIZE_NULL
, true),
1483 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true),
1484 SANITIZER_OPT (bool, SANITIZE_BOOL
, true),
1485 SANITIZER_OPT (enum, SANITIZE_ENUM
, true),
1486 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true),
1487 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true),
1488 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true),
1489 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true),
1490 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true),
1491 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true),
1492 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
1494 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true),
1495 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true),
1496 SANITIZER_OPT (all
, ~0U, true),
1497 #undef SANITIZER_OPT
1498 { NULL
, 0U, 0UL, false }
1501 /* A struct for describing a run of chars within a string. */
1503 struct string_fragment
1505 string_fragment (const char *start
, size_t len
)
1506 : m_start (start
), m_len (len
) {}
1508 const char *m_start
;
1512 /* Specialization of edit_distance_traits for string_fragment,
1513 for use by get_closest_sanitizer_option. */
1516 struct edit_distance_traits
<const string_fragment
&>
1518 static size_t get_length (const string_fragment
&fragment
)
1520 return fragment
.m_len
;
1523 static const char *get_string (const string_fragment
&fragment
)
1525 return fragment
.m_start
;
1529 /* Given ARG, an unrecognized sanitizer option, return the best
1530 matching sanitizer option, or NULL if there isn't one.
1531 CODE is OPT_fsanitize_ or OPT_fsanitize_recover_.
1532 VALUE is non-zero for the regular form of the option, zero
1533 for the "no-" form (e.g. "-fno-sanitize-recover="). */
1536 get_closest_sanitizer_option (const string_fragment
&arg
,
1537 enum opt_code code
, int value
)
1539 best_match
<const string_fragment
&, const char*> bm (arg
);
1540 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1542 /* -fsanitize=all is not valid, so don't offer it. */
1543 if (sanitizer_opts
[i
].flag
== ~0U
1544 && code
== OPT_fsanitize_
1548 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
1549 don't offer the non-recoverable options. */
1550 if (!sanitizer_opts
[i
].can_recover
1551 && code
== OPT_fsanitize_recover_
1555 bm
.consider (sanitizer_opts
[i
].name
);
1557 return bm
.get_best_meaningful_candidate ();
1560 /* Parse comma separated sanitizer suboptions from P for option SCODE,
1561 adjust previous FLAGS and return new ones. If COMPLAIN is false,
1562 don't issue diagnostics. */
1565 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
1566 unsigned int flags
, int value
, bool complain
)
1568 enum opt_code code
= (enum opt_code
) scode
;
1573 const char *comma
= strchr (p
, ',');
1585 /* Check to see if the string matches an option class name. */
1586 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1587 if (len
== sanitizer_opts
[i
].len
1588 && memcmp (p
, sanitizer_opts
[i
].name
, len
) == 0)
1590 /* Handle both -fsanitize and -fno-sanitize cases. */
1591 if (value
&& sanitizer_opts
[i
].flag
== ~0U)
1593 if (code
== OPT_fsanitize_
)
1596 error_at (loc
, "-fsanitize=all option is not valid");
1599 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
1600 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
1604 /* Do not enable -fsanitize-recover=unreachable and
1605 -fsanitize-recover=return if -fsanitize-recover=undefined
1607 if (code
== OPT_fsanitize_recover_
1608 && sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
1609 flags
|= (SANITIZE_UNDEFINED
1610 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
1612 flags
|= sanitizer_opts
[i
].flag
;
1615 flags
&= ~sanitizer_opts
[i
].flag
;
1620 if (! found
&& complain
)
1623 = get_closest_sanitizer_option (string_fragment (p
, len
),
1628 "unrecognized argument to -f%ssanitize%s= option: %q.*s;"
1629 " did you mean %qs?",
1631 code
== OPT_fsanitize_
? "" : "-recover",
1632 (int) len
, p
, hint
);
1635 "unrecognized argument to -f%ssanitize%s= option: %q.*s",
1637 code
== OPT_fsanitize_
? "" : "-recover",
1648 /* Handle target- and language-independent options. Return zero to
1649 generate an "unknown option" message. Only options that need
1650 extra handling need to be listed here; if you simply want
1651 DECODED->value assigned to a variable, it happens automatically. */
1654 common_handle_option (struct gcc_options
*opts
,
1655 struct gcc_options
*opts_set
,
1656 const struct cl_decoded_option
*decoded
,
1657 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
1659 const struct cl_option_handlers
*handlers
,
1660 diagnostic_context
*dc
)
1662 size_t scode
= decoded
->opt_index
;
1663 const char *arg
= decoded
->arg
;
1664 int value
= decoded
->value
;
1665 enum opt_code code
= (enum opt_code
) scode
;
1667 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
1672 handle_param (opts
, opts_set
, loc
, arg
);
1677 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1678 unsigned int undoc_mask
;
1681 if (lang_mask
== CL_DRIVER
)
1684 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
1687 /* First display any single language specific options. */
1688 for (i
= 0; i
< cl_lang_count
; i
++)
1690 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
1692 /* Next display any multi language specific options. */
1693 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
1694 /* Then display any remaining, non-language options. */
1695 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
1697 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
1698 opts
->x_exit_after_options
= true;
1702 case OPT__target_help
:
1703 if (lang_mask
== CL_DRIVER
)
1706 print_specific_help (CL_TARGET
, CL_UNDOCUMENTED
, 0, opts
, lang_mask
);
1707 opts
->x_exit_after_options
= true;
1712 const char *a
= arg
;
1713 unsigned int include_flags
= 0;
1714 /* Note - by default we include undocumented options when listing
1715 specific classes. If you only want to see documented options
1716 then add ",^undocumented" to the --help= option. E.g.:
1718 --help=target,^undocumented */
1719 unsigned int exclude_flags
= 0;
1721 if (lang_mask
== CL_DRIVER
)
1724 /* Walk along the argument string, parsing each word in turn.
1726 arg = [^]{word}[,{arg}]
1727 word = {optimizers|target|warnings|undocumented|
1728 params|common|<language>} */
1738 { "optimizers", CL_OPTIMIZATION
},
1739 { "target", CL_TARGET
},
1740 { "warnings", CL_WARNING
},
1741 { "undocumented", CL_UNDOCUMENTED
},
1742 { "params", CL_PARAMS
},
1743 { "joined", CL_JOINED
},
1744 { "separate", CL_SEPARATE
},
1745 { "common", CL_COMMON
},
1748 unsigned int *pflags
;
1750 unsigned int lang_flag
, specific_flag
;
1759 error_at (loc
, "missing argument to %qs", "--help=^");
1762 pflags
= &exclude_flags
;
1765 pflags
= &include_flags
;
1767 comma
= strchr (a
, ',');
1778 /* Check to see if the string matches an option class name. */
1779 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
1780 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
1782 specific_flag
= specifics
[i
].flag
;
1786 /* Check to see if the string matches a language name.
1787 Note - we rely upon the alpha-sorted nature of the entries in
1788 the lang_names array, specifically that shorter names appear
1789 before their longer variants. (i.e. C before C++). That way
1790 when we are attempting to match --help=c for example we will
1791 match with C first and not C++. */
1792 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
1793 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
1795 lang_flag
= 1U << i
;
1799 if (specific_flag
!= 0)
1802 *pflags
|= specific_flag
;
1805 /* The option's argument matches both the start of a
1806 language name and the start of an option class name.
1807 We have a special case for when the user has
1808 specified "--help=c", but otherwise we have to issue
1810 if (strncasecmp (a
, "c", len
) == 0)
1811 *pflags
|= lang_flag
;
1814 "--help argument %q.*s is ambiguous, "
1815 "please be more specific",
1819 else if (lang_flag
!= 0)
1820 *pflags
|= lang_flag
;
1823 "unrecognized argument to --help= option: %q.*s",
1832 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
1834 opts
->x_exit_after_options
= true;
1839 if (lang_mask
== CL_DRIVER
)
1842 opts
->x_exit_after_options
= true;
1845 case OPT_fsanitize_
:
1846 opts
->x_flag_sanitize
1847 = parse_sanitizer_options (arg
, loc
, code
,
1848 opts
->x_flag_sanitize
, value
, true);
1850 /* Kernel ASan implies normal ASan but does not yet support
1852 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
1854 maybe_set_param_value (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD
,
1855 0, opts
->x_param_values
,
1856 opts_set
->x_param_values
);
1857 maybe_set_param_value (PARAM_ASAN_GLOBALS
, 0, opts
->x_param_values
,
1858 opts_set
->x_param_values
);
1859 maybe_set_param_value (PARAM_ASAN_STACK
, 0, opts
->x_param_values
,
1860 opts_set
->x_param_values
);
1861 maybe_set_param_value (PARAM_ASAN_USE_AFTER_RETURN
, 0,
1862 opts
->x_param_values
,
1863 opts_set
->x_param_values
);
1867 case OPT_fsanitize_recover_
:
1868 opts
->x_flag_sanitize_recover
1869 = parse_sanitizer_options (arg
, loc
, code
,
1870 opts
->x_flag_sanitize_recover
, value
, true);
1873 case OPT_fasan_shadow_offset_
:
1877 case OPT_fsanitize_address_use_after_scope
:
1878 opts
->x_flag_sanitize_address_use_after_scope
= value
;
1881 case OPT_fsanitize_recover
:
1883 opts
->x_flag_sanitize_recover
1884 |= (SANITIZE_UNDEFINED
| SANITIZE_NONDEFAULT
)
1885 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
1887 opts
->x_flag_sanitize_recover
1888 &= ~(SANITIZE_UNDEFINED
| SANITIZE_NONDEFAULT
);
1895 /* Currently handled in a prescan. */
1899 dc
->warning_as_error_requested
= value
;
1903 if (lang_mask
== CL_DRIVER
)
1906 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
1907 opts
, opts_set
, loc
, dc
);
1910 case OPT_Wlarger_than_
:
1911 opts
->x_larger_than_size
= value
;
1912 opts
->x_warn_larger_than
= value
!= -1;
1915 case OPT_Wfatal_errors
:
1916 dc
->fatal_errors
= value
;
1919 case OPT_Wframe_larger_than_
:
1920 opts
->x_frame_larger_than_size
= value
;
1921 opts
->x_warn_frame_larger_than
= value
!= -1;
1924 case OPT_Wstack_usage_
:
1925 opts
->x_warn_stack_usage
= value
;
1926 opts
->x_flag_stack_usage_info
= value
!= -1;
1929 case OPT_Wstrict_aliasing
:
1930 set_Wstrict_aliasing (opts
, value
);
1933 case OPT_Wstrict_overflow
:
1934 opts
->x_warn_strict_overflow
= (value
1935 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1939 case OPT_Wsystem_headers
:
1940 dc
->dc_warn_system_headers
= value
;
1944 opts
->x_flag_gen_aux_info
= 1;
1947 case OPT_auxbase_strip
:
1949 char *tmp
= xstrdup (arg
);
1950 strip_off_ending (tmp
, strlen (tmp
));
1952 opts
->x_aux_base_name
= tmp
;
1959 decode_d_option (arg
, opts
, loc
, dc
);
1962 case OPT_fcall_used_
:
1963 case OPT_fcall_saved_
:
1971 case OPT_fdbg_cnt_list
:
1973 opts
->x_exit_after_options
= true;
1976 case OPT_fdebug_prefix_map_
:
1980 case OPT_fdiagnostics_show_location_
:
1981 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
1984 case OPT_fdiagnostics_show_caret
:
1985 dc
->show_caret
= value
;
1988 case OPT_fdiagnostics_color_
:
1989 diagnostic_color_init (dc
, value
);
1992 case OPT_fdiagnostics_parseable_fixits
:
1993 dc
->parseable_fixits_p
= value
;
1996 case OPT_fdiagnostics_show_option
:
1997 dc
->show_option_requested
= value
;
2004 case OPT_ffast_math
:
2005 set_fast_math_flags (opts
, value
);
2008 case OPT_funsafe_math_optimizations
:
2009 set_unsafe_math_optimizations_flags (opts
, value
);
2016 case OPT_finline_limit_
:
2017 set_param_value ("max-inline-insns-single", value
/ 2,
2018 opts
->x_param_values
, opts_set
->x_param_values
);
2019 set_param_value ("max-inline-insns-auto", value
/ 2,
2020 opts
->x_param_values
, opts_set
->x_param_values
);
2023 case OPT_finstrument_functions_exclude_function_list_
:
2024 add_comma_separated_to_vector
2025 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2028 case OPT_finstrument_functions_exclude_file_list_
:
2029 add_comma_separated_to_vector
2030 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2033 case OPT_fmessage_length_
:
2034 pp_set_line_maximum_length (dc
->printer
, value
);
2035 diagnostic_set_caret_max_width (dc
, value
);
2039 case OPT_fopt_info_
:
2045 const char *p
= arg
;
2046 opts
->x_flag_disable_hsa
= true;
2049 const char *comma
= strchr (p
, ',');
2051 if ((strncmp (p
, "disable", 7) == 0)
2052 && (p
[7] == ',' || p
[7] == '\0'))
2054 opts
->x_flag_disable_hsa
= true;
2058 if ((strncmp (p
, "hsa", 3) == 0)
2059 && (p
[3] == ',' || p
[3] == '\0'))
2062 opts
->x_flag_disable_hsa
= false;
2064 sorry ("HSA has not been enabled during configuration");
2074 #ifndef ACCEL_COMPILER
2075 case OPT_foffload_abi_
:
2076 error_at (loc
, "-foffload-abi option can be specified only for "
2077 "offload compiler");
2081 case OPT_fpack_struct_
:
2082 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2084 "structure alignment must be a small power of two, not %d",
2087 opts
->x_initial_max_fld_align
= value
;
2091 case OPT_fplugin_arg_
:
2095 case OPT_fprofile_use_
:
2096 opts
->x_profile_data_prefix
= xstrdup (arg
);
2097 opts
->x_flag_profile_use
= true;
2099 /* No break here - do -fprofile-use processing. */
2101 case OPT_fprofile_use
:
2102 enable_fdo_optimizations (opts
, opts_set
, value
);
2103 if (!opts_set
->x_flag_profile_reorder_functions
)
2104 opts
->x_flag_profile_reorder_functions
= value
;
2105 /* Indirect call profiling should do all useful transformations
2106 speculative devirtualization does. */
2107 if (!opts_set
->x_flag_devirtualize_speculatively
2108 && opts
->x_flag_value_profile_transformations
)
2109 opts
->x_flag_devirtualize_speculatively
= false;
2112 case OPT_fauto_profile_
:
2113 opts
->x_auto_profile_file
= xstrdup (arg
);
2114 opts
->x_flag_auto_profile
= true;
2116 /* No break here - do -fauto-profile processing. */
2118 case OPT_fauto_profile
:
2119 enable_fdo_optimizations (opts
, opts_set
, value
);
2120 if (!opts_set
->x_flag_profile_correction
)
2121 opts
->x_flag_profile_correction
= value
;
2122 maybe_set_param_value (
2123 PARAM_EARLY_INLINER_MAX_ITERATIONS
, 10,
2124 opts
->x_param_values
, opts_set
->x_param_values
);
2127 case OPT_fprofile_generate_
:
2128 opts
->x_profile_data_prefix
= xstrdup (arg
);
2130 /* No break here - do -fprofile-generate processing. */
2132 case OPT_fprofile_generate
:
2133 if (!opts_set
->x_profile_arc_flag
)
2134 opts
->x_profile_arc_flag
= value
;
2135 if (!opts_set
->x_flag_profile_values
)
2136 opts
->x_flag_profile_values
= value
;
2137 if (!opts_set
->x_flag_inline_functions
)
2138 opts
->x_flag_inline_functions
= value
;
2139 if (!opts_set
->x_flag_ipa_bit_cp
)
2140 opts
->x_flag_ipa_bit_cp
= value
;
2141 /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
2142 quadratic. Disable the pass until better memory representation
2144 if (!opts_set
->x_flag_ipa_reference
)
2145 opts
->x_flag_ipa_reference
= false;
2148 case OPT_ftree_vectorize
:
2149 if (!opts_set
->x_flag_tree_loop_vectorize
)
2150 opts
->x_flag_tree_loop_vectorize
= value
;
2151 if (!opts_set
->x_flag_tree_slp_vectorize
)
2152 opts
->x_flag_tree_slp_vectorize
= value
;
2154 case OPT_fshow_column
:
2155 dc
->show_column
= value
;
2158 case OPT_frandom_seed
:
2159 /* The real switch is -fno-random-seed. */
2165 case OPT_frandom_seed_
:
2169 case OPT_fsched_verbose_
:
2170 #ifdef INSN_SCHEDULING
2171 /* Handled with Var in common.opt. */
2177 case OPT_fsched_stalled_insns_
:
2178 opts
->x_flag_sched_stalled_insns
= value
;
2179 if (opts
->x_flag_sched_stalled_insns
== 0)
2180 opts
->x_flag_sched_stalled_insns
= -1;
2183 case OPT_fsched_stalled_insns_dep_
:
2184 opts
->x_flag_sched_stalled_insns_dep
= value
;
2187 case OPT_fstack_check_
:
2188 if (!strcmp (arg
, "no"))
2189 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
2190 else if (!strcmp (arg
, "generic"))
2191 /* This is the old stack checking method. */
2192 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2193 ? FULL_BUILTIN_STACK_CHECK
2194 : GENERIC_STACK_CHECK
;
2195 else if (!strcmp (arg
, "specific"))
2196 /* This is the new stack checking method. */
2197 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2198 ? FULL_BUILTIN_STACK_CHECK
2199 : STACK_CHECK_STATIC_BUILTIN
2200 ? STATIC_BUILTIN_STACK_CHECK
2201 : GENERIC_STACK_CHECK
;
2203 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
2206 case OPT_fstack_limit
:
2207 /* The real switch is -fno-stack-limit. */
2213 case OPT_fstack_limit_register_
:
2214 case OPT_fstack_limit_symbol_
:
2218 case OPT_fstack_usage
:
2219 opts
->x_flag_stack_usage
= value
;
2220 opts
->x_flag_stack_usage_info
= value
!= 0;
2224 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
2229 set_debug_level (SDB_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2233 if (arg
&& strlen (arg
) != 0)
2235 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
2236 "use %<-gdwarf-%s%> for DWARF version "
2237 "or %<-gdwarf -g%s%> for debug level", arg
, arg
, arg
);
2241 value
= opts
->x_dwarf_version
;
2245 if (value
< 2 || value
> 5)
2246 error_at (loc
, "dwarf version %d is not supported", value
);
2248 opts
->x_dwarf_version
= value
;
2249 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
2252 case OPT_gsplit_dwarf
:
2253 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, "", opts
, opts_set
,
2258 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
2263 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
, opts
, opts_set
,
2268 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2273 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
, opts
, opts_set
,
2279 /* Handled completely via specs. */
2282 case OPT_pedantic_errors
:
2283 dc
->pedantic_errors
= 1;
2284 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
2286 handlers
, opts
, opts_set
,
2291 opts
->x_flag_lto
= value
? "" : NULL
;
2295 dc
->dc_inhibit_warnings
= true;
2298 case OPT_fmax_errors_
:
2299 dc
->max_errors
= value
;
2302 case OPT_fuse_ld_bfd
:
2303 case OPT_fuse_ld_gold
:
2304 case OPT_fuse_linker_plugin
:
2305 /* No-op. Used by the driver and passed to us because it starts with f.*/
2310 opts
->x_flag_trapv
= 0;
2315 opts
->x_flag_wrapv
= 0;
2319 opts
->x_flag_ipa_icf_functions
= value
;
2320 opts
->x_flag_ipa_icf_variables
= value
;
2324 /* If the flag was handled in a standard way, assume the lack of
2325 processing here is intentional. */
2326 gcc_assert (option_flag_var (scode
, opts
));
2330 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
2335 /* Handle --param NAME=VALUE. */
2337 handle_param (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2338 location_t loc
, const char *carg
)
2343 arg
= xstrdup (carg
);
2344 equal
= strchr (arg
, '=');
2346 error_at (loc
, "%s: --param arguments should be of the form NAME=VALUE",
2352 enum compiler_param index
;
2353 if (!find_param (arg
, &index
))
2355 const char *suggestion
= find_param_fuzzy (arg
);
2357 error_at (loc
, "invalid --param name %qs; did you mean %qs?",
2360 error_at (loc
, "invalid --param name %qs", arg
);
2364 if (!param_string_value_p (index
, equal
+ 1, &value
))
2365 value
= integral_argument (equal
+ 1);
2368 error_at (loc
, "invalid --param value %qs", equal
+ 1);
2370 set_param_value (arg
, value
,
2371 opts
->x_param_values
, opts_set
->x_param_values
);
2378 /* Used to set the level of strict aliasing warnings in OPTS,
2379 when no level is specified (i.e., when -Wstrict-aliasing, and not
2380 -Wstrict-aliasing=level was given).
2381 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2382 and 0 otherwise. After calling this function, wstrict_aliasing will be
2383 set to the default value of -Wstrict_aliasing=level, currently 3. */
2385 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
2387 gcc_assert (onoff
== 0 || onoff
== 1);
2389 opts
->x_warn_strict_aliasing
= 3;
2391 opts
->x_warn_strict_aliasing
= 0;
2394 /* The following routines are useful in setting all the flags that
2395 -ffast-math and -fno-fast-math imply. */
2397 set_fast_math_flags (struct gcc_options
*opts
, int set
)
2399 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
2401 opts
->x_flag_unsafe_math_optimizations
= set
;
2402 set_unsafe_math_optimizations_flags (opts
, set
);
2404 if (!opts
->frontend_set_flag_finite_math_only
)
2405 opts
->x_flag_finite_math_only
= set
;
2406 if (!opts
->frontend_set_flag_errno_math
)
2407 opts
->x_flag_errno_math
= !set
;
2410 if (opts
->frontend_set_flag_excess_precision_cmdline
2411 == EXCESS_PRECISION_DEFAULT
)
2412 opts
->x_flag_excess_precision_cmdline
2413 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
2414 if (!opts
->frontend_set_flag_signaling_nans
)
2415 opts
->x_flag_signaling_nans
= 0;
2416 if (!opts
->frontend_set_flag_rounding_math
)
2417 opts
->x_flag_rounding_math
= 0;
2418 if (!opts
->frontend_set_flag_cx_limited_range
)
2419 opts
->x_flag_cx_limited_range
= 1;
2423 /* When -funsafe-math-optimizations is set the following
2424 flags are set as well. */
2426 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
2428 if (!opts
->frontend_set_flag_trapping_math
)
2429 opts
->x_flag_trapping_math
= !set
;
2430 if (!opts
->frontend_set_flag_signed_zeros
)
2431 opts
->x_flag_signed_zeros
= !set
;
2432 if (!opts
->frontend_set_flag_associative_math
)
2433 opts
->x_flag_associative_math
= set
;
2434 if (!opts
->frontend_set_flag_reciprocal_math
)
2435 opts
->x_flag_reciprocal_math
= set
;
2438 /* Return true iff flags in OPTS are set as if -ffast-math. */
2440 fast_math_flags_set_p (const struct gcc_options
*opts
)
2442 return (!opts
->x_flag_trapping_math
2443 && opts
->x_flag_unsafe_math_optimizations
2444 && opts
->x_flag_finite_math_only
2445 && !opts
->x_flag_signed_zeros
2446 && !opts
->x_flag_errno_math
2447 && opts
->x_flag_excess_precision_cmdline
2448 == EXCESS_PRECISION_FAST
);
2451 /* Return true iff flags are set as if -ffast-math but using the flags stored
2452 in the struct cl_optimization structure. */
2454 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
2456 return (!opt
->x_flag_trapping_math
2457 && opt
->x_flag_unsafe_math_optimizations
2458 && opt
->x_flag_finite_math_only
2459 && !opt
->x_flag_signed_zeros
2460 && !opt
->x_flag_errno_math
);
2463 /* Handle a debug output -g switch for options OPTS
2464 (OPTS_SET->x_write_symbols storing whether a debug type was passed
2465 explicitly), location LOC. EXTENDED is true or false to support
2466 extended output (2 is special and means "-ggdb" was given). */
2468 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
,
2469 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2472 opts
->x_use_gnu_debug_info_extensions
= extended
;
2474 if (type
== NO_DEBUG
)
2476 if (opts
->x_write_symbols
== NO_DEBUG
)
2478 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
2482 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
2483 opts
->x_write_symbols
= DWARF2_DEBUG
;
2484 #elif defined DBX_DEBUGGING_INFO
2485 opts
->x_write_symbols
= DBX_DEBUG
;
2489 if (opts
->x_write_symbols
== NO_DEBUG
)
2490 warning_at (loc
, 0, "target system does not support debug output");
2495 /* Does it conflict with an already selected type? */
2496 if (opts_set
->x_write_symbols
!= NO_DEBUG
2497 && opts
->x_write_symbols
!= NO_DEBUG
2498 && type
!= opts
->x_write_symbols
)
2499 error_at (loc
, "debug format %qs conflicts with prior selection",
2500 debug_type_names
[type
]);
2501 opts
->x_write_symbols
= type
;
2502 opts_set
->x_write_symbols
= type
;
2505 /* A debug flag without a level defaults to level 2.
2506 If off or at level 1, set it to level 2, but if already
2507 at level 3, don't lower it. */
2510 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
2511 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
2515 int argval
= integral_argument (arg
);
2517 error_at (loc
, "unrecognized debug output level %qs", arg
);
2518 else if (argval
> 3)
2519 error_at (loc
, "debug output level %qs is too high", arg
);
2521 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
2525 /* Arrange to dump core on error for diagnostic context DC. (The
2526 regular error message is still printed first, except in the case of
2530 setup_core_dumping (diagnostic_context
*dc
)
2533 signal (SIGABRT
, SIG_DFL
);
2535 #if defined(HAVE_SETRLIMIT)
2538 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
2539 fatal_error (input_location
, "getting core file size maximum limit: %m");
2540 rlim
.rlim_cur
= rlim
.rlim_max
;
2541 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
2542 fatal_error (input_location
,
2543 "setting core file size limit to maximum: %m");
2546 diagnostic_abort_on_error (dc
);
2549 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
2550 diagnostic context DC. */
2553 decode_d_option (const char *arg
, struct gcc_options
*opts
,
2554 location_t loc
, diagnostic_context
*dc
)
2562 opts
->x_flag_debug_asm
= 1;
2565 opts
->x_flag_print_asm_name
= 1;
2568 opts
->x_flag_dump_rtl_in_asm
= 1;
2569 opts
->x_flag_print_asm_name
= 1;
2572 opts
->x_rtl_dump_and_exit
= 1;
2574 case 'D': /* These are handled by the preprocessor. */
2581 setup_core_dumping (dc
);
2584 opts
->x_flag_dump_all_passed
= true;
2588 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
2593 /* Enable (or disable if VALUE is 0) a warning option ARG (language
2594 mask LANG_MASK, option handlers HANDLERS) as an error for option
2595 structures OPTS and OPTS_SET, diagnostic context DC (possibly
2596 NULL), location LOC. This is used by -Werror=. */
2599 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
2600 const struct cl_option_handlers
*handlers
,
2601 struct gcc_options
*opts
,
2602 struct gcc_options
*opts_set
,
2603 location_t loc
, diagnostic_context
*dc
)
2608 new_option
= XNEWVEC (char, strlen (arg
) + 2);
2609 new_option
[0] = 'W';
2610 strcpy (new_option
+ 1, arg
);
2611 option_index
= find_opt (new_option
, lang_mask
);
2612 if (option_index
== OPT_SPECIAL_unknown
)
2613 error_at (loc
, "-Werror=%s: no option -%s", arg
, new_option
);
2614 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
2615 error_at (loc
, "-Werror=%s: -%s is not an option that controls warnings",
2619 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
2620 const char *arg
= NULL
;
2622 if (cl_options
[option_index
].flags
& CL_JOINED
)
2623 arg
= new_option
+ cl_options
[option_index
].opt_len
;
2624 control_warning_option (option_index
, (int) kind
, arg
, value
,
2626 handlers
, opts
, opts_set
, dc
);
2631 /* Return malloced memory for the name of the option OPTION_INDEX
2632 which enabled a diagnostic (context CONTEXT), originally of type
2633 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2637 option_name (diagnostic_context
*context
, int option_index
,
2638 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
2642 /* A warning classified as an error. */
2643 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
2644 && diag_kind
== DK_ERROR
)
2645 return concat (cl_options
[OPT_Werror_
].opt_text
,
2646 /* Skip over "-W". */
2647 cl_options
[option_index
].opt_text
+ 2,
2649 /* A warning with option. */
2651 return xstrdup (cl_options
[option_index
].opt_text
);
2653 /* A warning without option classified as an error. */
2654 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
2655 || diag_kind
== DK_WARNING
)
2656 && context
->warning_as_error_requested
)
2657 return xstrdup (cl_options
[OPT_Werror
].opt_text
);