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
, 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 },
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
, OPT_fstrict_overflow
, 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_fpredictive_commoning
, NULL
, 1 },
530 { OPT_LEVELS_3_PLUS
, OPT_fsplit_paths
, NULL
, 1 },
531 /* Inlining of functions reducing size is a good idea with -Os
532 regardless of them being declared inline. */
533 { OPT_LEVELS_3_PLUS_AND_SIZE
, OPT_finline_functions
, NULL
, 1 },
534 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_finline_functions_called_once
, NULL
, 1 },
535 { OPT_LEVELS_3_PLUS
, OPT_fsplit_loops
, NULL
, 1 },
536 { OPT_LEVELS_3_PLUS
, OPT_funswitch_loops
, NULL
, 1 },
537 { OPT_LEVELS_3_PLUS
, OPT_fgcse_after_reload
, NULL
, 1 },
538 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_vectorize
, NULL
, 1 },
539 { OPT_LEVELS_3_PLUS
, OPT_ftree_slp_vectorize
, NULL
, 1 },
540 { OPT_LEVELS_3_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_DYNAMIC
},
541 { OPT_LEVELS_3_PLUS
, OPT_fipa_cp_clone
, NULL
, 1 },
542 { OPT_LEVELS_3_PLUS
, OPT_ftree_partial_pre
, NULL
, 1 },
543 { OPT_LEVELS_3_PLUS
, OPT_fpeel_loops
, NULL
, 1 },
545 /* -Ofast adds optimizations to -O3. */
546 { OPT_LEVELS_FAST
, OPT_ffast_math
, NULL
, 1 },
548 { OPT_LEVELS_NONE
, 0, NULL
, 0 }
551 /* Default the options in OPTS and OPTS_SET based on the optimization
552 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
554 default_options_optimization (struct gcc_options
*opts
,
555 struct gcc_options
*opts_set
,
556 struct cl_decoded_option
*decoded_options
,
557 unsigned int decoded_options_count
,
559 unsigned int lang_mask
,
560 const struct cl_option_handlers
*handlers
,
561 diagnostic_context
*dc
)
565 bool openacc_mode
= false;
567 /* Scan to see what optimization level has been specified. That will
568 determine the default value of many flags. */
569 for (i
= 1; i
< decoded_options_count
; i
++)
571 struct cl_decoded_option
*opt
= &decoded_options
[i
];
572 switch (opt
->opt_index
)
575 if (*opt
->arg
== '\0')
577 opts
->x_optimize
= 1;
578 opts
->x_optimize_size
= 0;
579 opts
->x_optimize_fast
= 0;
580 opts
->x_optimize_debug
= 0;
584 const int optimize_val
= integral_argument (opt
->arg
);
585 if (optimize_val
== -1)
586 error_at (loc
, "argument to %<-O%> should be a non-negative "
587 "integer, %<g%>, %<s%> or %<fast%>");
590 opts
->x_optimize
= optimize_val
;
591 if ((unsigned int) opts
->x_optimize
> 255)
592 opts
->x_optimize
= 255;
593 opts
->x_optimize_size
= 0;
594 opts
->x_optimize_fast
= 0;
595 opts
->x_optimize_debug
= 0;
601 opts
->x_optimize_size
= 1;
603 /* Optimizing for size forces optimize to be 2. */
604 opts
->x_optimize
= 2;
605 opts
->x_optimize_fast
= 0;
606 opts
->x_optimize_debug
= 0;
610 /* -Ofast only adds flags to -O3. */
611 opts
->x_optimize_size
= 0;
612 opts
->x_optimize
= 3;
613 opts
->x_optimize_fast
= 1;
614 opts
->x_optimize_debug
= 0;
618 /* -Og selects optimization level 1. */
619 opts
->x_optimize_size
= 0;
620 opts
->x_optimize
= 1;
621 opts
->x_optimize_fast
= 0;
622 opts
->x_optimize_debug
= 1;
631 /* Ignore other options in this prescan. */
636 maybe_default_options (opts
, opts_set
, default_options_table
,
637 opts
->x_optimize
, opts
->x_optimize_size
,
638 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
639 lang_mask
, handlers
, loc
, dc
);
641 /* -O2 param settings. */
642 opt2
= (opts
->x_optimize
>= 2);
645 && !opts_set
->x_flag_ipa_pta
)
646 opts
->x_flag_ipa_pta
= true;
648 /* Track fields in field-sensitive alias analysis. */
649 maybe_set_param_value
650 (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
,
651 opt2
? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
),
652 opts
->x_param_values
, opts_set
->x_param_values
);
654 /* For -O1 only do loop invariant motion for very small loops. */
655 maybe_set_param_value
656 (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
,
657 opt2
? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
) : 1000,
658 opts
->x_param_values
, opts_set
->x_param_values
);
660 /* At -Ofast, allow store motion to introduce potential race conditions. */
661 maybe_set_param_value
662 (PARAM_ALLOW_STORE_DATA_RACES
,
663 opts
->x_optimize_fast
? 1
664 : default_param_value (PARAM_ALLOW_STORE_DATA_RACES
),
665 opts
->x_param_values
, opts_set
->x_param_values
);
667 if (opts
->x_optimize_size
)
668 /* We want to crossjump as much as possible. */
669 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
, 1,
670 opts
->x_param_values
, opts_set
->x_param_values
);
672 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
,
673 default_param_value (PARAM_MIN_CROSSJUMP_INSNS
),
674 opts
->x_param_values
, opts_set
->x_param_values
);
676 /* Restrict the amount of work combine does at -Og while retaining
677 most of its useful transforms. */
678 if (opts
->x_optimize_debug
)
679 maybe_set_param_value (PARAM_MAX_COMBINE_INSNS
, 2,
680 opts
->x_param_values
, opts_set
->x_param_values
);
682 /* Allow default optimizations to be specified on a per-machine basis. */
683 maybe_default_options (opts
, opts_set
,
684 targetm_common
.option_optimization_table
,
685 opts
->x_optimize
, opts
->x_optimize_size
,
686 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
687 lang_mask
, handlers
, loc
, dc
);
690 /* After all options at LOC have been read into OPTS and OPTS_SET,
691 finalize settings of those options and diagnose incompatible
694 finish_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
697 enum unwind_info_type ui_except
;
699 if (opts
->x_dump_base_name
700 && ! IS_ABSOLUTE_PATH (opts
->x_dump_base_name
)
701 && ! opts
->x_dump_base_name_prefixed
)
703 /* First try to make OPTS->X_DUMP_BASE_NAME relative to the
704 OPTS->X_DUMP_DIR_NAME directory. Then try to make
705 OPTS->X_DUMP_BASE_NAME relative to the OPTS->X_AUX_BASE_NAME
706 directory, typically the directory to contain the object
708 if (opts
->x_dump_dir_name
)
709 opts
->x_dump_base_name
= opts_concat (opts
->x_dump_dir_name
,
710 opts
->x_dump_base_name
, NULL
);
711 else if (opts
->x_aux_base_name
712 && strcmp (opts
->x_aux_base_name
, HOST_BIT_BUCKET
) != 0)
714 const char *aux_base
;
716 base_of_path (opts
->x_aux_base_name
, &aux_base
);
717 if (opts
->x_aux_base_name
!= aux_base
)
719 int dir_len
= aux_base
- opts
->x_aux_base_name
;
720 char *new_dump_base_name
721 = XOBNEWVEC (&opts_obstack
, char,
722 strlen (opts
->x_dump_base_name
) + dir_len
+ 1);
724 /* Copy directory component from OPTS->X_AUX_BASE_NAME. */
725 memcpy (new_dump_base_name
, opts
->x_aux_base_name
, dir_len
);
726 /* Append existing OPTS->X_DUMP_BASE_NAME. */
727 strcpy (new_dump_base_name
+ dir_len
, opts
->x_dump_base_name
);
728 opts
->x_dump_base_name
= new_dump_base_name
;
731 opts
->x_dump_base_name_prefixed
= true;
734 /* Handle related options for unit-at-a-time, toplevel-reorder, and
736 if (!opts
->x_flag_unit_at_a_time
)
738 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
739 error_at (loc
, "section anchors must be disabled when unit-at-a-time "
741 opts
->x_flag_section_anchors
= 0;
742 if (opts
->x_flag_toplevel_reorder
== 1)
743 error_at (loc
, "toplevel reorder must be disabled when unit-at-a-time "
745 opts
->x_flag_toplevel_reorder
= 0;
748 /* -fself-test depends on the state of the compiler prior to
749 compiling anything. Ideally it should be run on an empty source
750 file. However, in case we get run with actual source, assume
751 -fsyntax-only which will inhibit any compiler initialization
752 which may confuse the self tests. */
753 if (opts
->x_flag_self_test
)
754 opts
->x_flag_syntax_only
= 1;
756 if (opts
->x_flag_tm
&& opts
->x_flag_non_call_exceptions
)
757 sorry ("transactional memory is not supported with non-call exceptions");
759 /* Unless the user has asked for section anchors, we disable toplevel
760 reordering at -O0 to disable transformations that might be surprising
761 to end users and to get -fno-toplevel-reorder tested. */
762 if (!opts
->x_optimize
763 && opts
->x_flag_toplevel_reorder
== 2
764 && !(opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
))
766 opts
->x_flag_toplevel_reorder
= 0;
767 opts
->x_flag_section_anchors
= 0;
769 if (!opts
->x_flag_toplevel_reorder
)
771 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
772 error_at (loc
, "section anchors must be disabled when toplevel reorder"
774 opts
->x_flag_section_anchors
= 0;
777 if (!opts
->x_flag_opts_finished
)
779 /* We initialize opts->x_flag_pie to -1 so that targets can set a
781 if (opts
->x_flag_pie
== -1)
783 /* We initialize opts->x_flag_pic to -1 so that we can tell if
784 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
785 if (opts
->x_flag_pic
== -1)
786 opts
->x_flag_pie
= DEFAULT_FLAG_PIE
;
788 opts
->x_flag_pie
= 0;
790 /* If -fPIE or -fpie is used, turn on PIC. */
791 if (opts
->x_flag_pie
)
792 opts
->x_flag_pic
= opts
->x_flag_pie
;
793 else if (opts
->x_flag_pic
== -1)
794 opts
->x_flag_pic
= 0;
795 if (opts
->x_flag_pic
&& !opts
->x_flag_pie
)
796 opts
->x_flag_shlib
= 1;
797 opts
->x_flag_opts_finished
= true;
800 /* We initialize opts->x_flag_stack_protect to -1 so that targets
801 can set a default value. */
802 if (opts
->x_flag_stack_protect
== -1)
803 opts
->x_flag_stack_protect
= DEFAULT_FLAG_SSP
;
805 if (opts
->x_optimize
== 0)
807 /* Inlining does not work if not optimizing,
808 so force it not to be done. */
809 opts
->x_warn_inline
= 0;
810 opts
->x_flag_no_inline
= 1;
813 /* The optimization to partition hot and cold basic blocks into separate
814 sections of the .o and executable files does not work (currently)
815 with exception handling. This is because there is no support for
816 generating unwind info. If opts->x_flag_exceptions is turned on
817 we need to turn off the partitioning optimization. */
819 ui_except
= targetm_common
.except_unwind_info (opts
);
821 if (opts
->x_flag_exceptions
822 && opts
->x_flag_reorder_blocks_and_partition
823 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
825 if (opts_set
->x_flag_reorder_blocks_and_partition
)
827 "-freorder-blocks-and-partition does not work "
828 "with exceptions on this architecture");
829 opts
->x_flag_reorder_blocks_and_partition
= 0;
830 opts
->x_flag_reorder_blocks
= 1;
833 /* If user requested unwind info, then turn off the partitioning
836 if (opts
->x_flag_unwind_tables
837 && !targetm_common
.unwind_tables_default
838 && opts
->x_flag_reorder_blocks_and_partition
839 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
841 if (opts_set
->x_flag_reorder_blocks_and_partition
)
843 "-freorder-blocks-and-partition does not support "
844 "unwind info on this architecture");
845 opts
->x_flag_reorder_blocks_and_partition
= 0;
846 opts
->x_flag_reorder_blocks
= 1;
849 /* If the target requested unwind info, then turn off the partitioning
850 optimization with a different message. Likewise, if the target does not
851 support named sections. */
853 if (opts
->x_flag_reorder_blocks_and_partition
854 && (!targetm_common
.have_named_sections
855 || (opts
->x_flag_unwind_tables
856 && targetm_common
.unwind_tables_default
857 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
859 if (opts_set
->x_flag_reorder_blocks_and_partition
)
861 "-freorder-blocks-and-partition does not work "
862 "on this architecture");
863 opts
->x_flag_reorder_blocks_and_partition
= 0;
864 opts
->x_flag_reorder_blocks
= 1;
867 /* Disable -freorder-blocks-and-partition when -fprofile-use is not in
868 effect. Function splitting was not actually being performed in that case,
869 as probably_never_executed_bb_p does not distinguish any basic blocks as
870 being cold vs hot when there is no profile data. Leaving it enabled,
871 however, causes the assembly code generator to create (empty) cold
872 sections and labels, leading to unnecessary size overhead. */
873 if (opts
->x_flag_reorder_blocks_and_partition
874 && !opts_set
->x_flag_profile_use
)
875 opts
->x_flag_reorder_blocks_and_partition
= 0;
877 if (opts
->x_flag_reorder_blocks_and_partition
878 && !opts_set
->x_flag_reorder_functions
)
879 opts
->x_flag_reorder_functions
= 1;
881 /* Pipelining of outer loops is only possible when general pipelining
882 capabilities are requested. */
883 if (!opts
->x_flag_sel_sched_pipelining
)
884 opts
->x_flag_sel_sched_pipelining_outer_loops
= 0;
886 if (opts
->x_flag_conserve_stack
)
888 maybe_set_param_value (PARAM_LARGE_STACK_FRAME
, 100,
889 opts
->x_param_values
, opts_set
->x_param_values
);
890 maybe_set_param_value (PARAM_STACK_FRAME_GROWTH
, 40,
891 opts
->x_param_values
, opts_set
->x_param_values
);
894 if (opts
->x_flag_lto
)
897 opts
->x_flag_generate_lto
= 1;
899 /* When generating IL, do not operate in whole-program mode.
900 Otherwise, symbols will be privatized too early, causing link
902 opts
->x_flag_whole_program
= 0;
904 error_at (loc
, "LTO support has not been enabled in this configuration");
906 if (!opts
->x_flag_fat_lto_objects
908 || (opts_set
->x_flag_use_linker_plugin
909 && !opts
->x_flag_use_linker_plugin
)))
911 if (opts_set
->x_flag_fat_lto_objects
)
912 error_at (loc
, "-fno-fat-lto-objects are supported only with linker plugin");
913 opts
->x_flag_fat_lto_objects
= 1;
917 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
918 default value if they choose based on other options. */
919 if (opts
->x_flag_split_stack
== -1)
920 opts
->x_flag_split_stack
= 0;
921 else if (opts
->x_flag_split_stack
)
923 if (!targetm_common
.supports_split_stack (true, opts
))
925 error_at (loc
, "%<-fsplit-stack%> is not supported by "
926 "this compiler configuration");
927 opts
->x_flag_split_stack
= 0;
931 /* Tune vectorization related parametees according to cost model. */
932 if (opts
->x_flag_vect_cost_model
== VECT_COST_MODEL_CHEAP
)
934 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS
,
935 6, opts
->x_param_values
, opts_set
->x_param_values
);
936 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS
,
937 0, opts
->x_param_values
, opts_set
->x_param_values
);
938 maybe_set_param_value (PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT
,
939 0, opts
->x_param_values
, opts_set
->x_param_values
);
942 /* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
944 if ((!opts
->x_flag_tree_loop_vectorize
&& !opts
->x_flag_tree_slp_vectorize
)
945 || !opts
->x_flag_tree_loop_if_convert
)
946 maybe_set_param_value (PARAM_MAX_STORES_TO_SINK
, 0,
947 opts
->x_param_values
, opts_set
->x_param_values
);
949 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
950 if (opts
->x_dwarf_split_debug_info
)
951 opts
->x_debug_generate_pub_sections
= 2;
953 /* Userspace and kernel ASan conflict with each other. */
954 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
955 && (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
))
957 "-fsanitize=address is incompatible with "
958 "-fsanitize=kernel-address");
961 if ((opts
->x_flag_sanitize
& SANITIZE_ADDRESS
)
962 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
964 "-fsanitize=address and -fsanitize=kernel-address "
965 "are incompatible with -fsanitize=thread");
967 if ((opts
->x_flag_sanitize
& SANITIZE_LEAK
)
968 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
970 "-fsanitize=leak is incompatible with -fsanitize=thread");
972 /* Check error recovery for -fsanitize-recover option. */
973 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
974 if ((opts
->x_flag_sanitize_recover
& sanitizer_opts
[i
].flag
)
975 && !sanitizer_opts
[i
].can_recover
)
976 error_at (loc
, "-fsanitize-recover=%s is not supported",
977 sanitizer_opts
[i
].name
);
979 /* When instrumenting the pointers, we don't want to remove
980 the null pointer checks. */
981 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
982 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
983 opts
->x_flag_delete_null_pointer_checks
= 0;
985 /* Aggressive compiler optimizations may cause false negatives. */
986 if (opts
->x_flag_sanitize
& ~(SANITIZE_LEAK
| SANITIZE_UNREACHABLE
))
988 opts
->x_flag_aggressive_loop_optimizations
= 0;
989 opts
->x_flag_strict_overflow
= 0;
992 /* Enable -fsanitize-address-use-after-scope if address sanitizer is
994 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
995 && !opts_set
->x_flag_sanitize_address_use_after_scope
)
996 opts
->x_flag_sanitize_address_use_after_scope
= true;
998 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1000 if (opts
->x_flag_sanitize_address_use_after_scope
)
1002 if (opts
->x_flag_stack_reuse
!= SR_NONE
1003 && opts_set
->x_flag_stack_reuse
!= SR_NONE
)
1005 "-fsanitize-address-use-after-scope requires "
1006 "-fstack-reuse=none option");
1008 opts
->x_flag_stack_reuse
= SR_NONE
;
1011 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
) && opts
->x_flag_tm
)
1012 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1014 if ((opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) && opts
->x_flag_tm
)
1015 sorry ("transactional memory is not supported with "
1016 "%<-fsanitize=kernel-address%>");
1019 #define LEFT_COLUMN 27
1021 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1022 followed by word-wrapped HELP in a second column. */
1024 wrap_help (const char *help
,
1026 unsigned int item_width
,
1027 unsigned int columns
)
1029 unsigned int col_width
= LEFT_COLUMN
;
1030 unsigned int remaining
, room
, len
;
1032 remaining
= strlen (help
);
1036 room
= columns
- 3 - MAX (col_width
, item_width
);
1045 for (i
= 0; help
[i
]; i
++)
1047 if (i
>= room
&& len
!= remaining
)
1051 else if ((help
[i
] == '-' || help
[i
] == '/')
1052 && help
[i
+ 1] != ' '
1053 && i
> 0 && ISALPHA (help
[i
- 1]))
1058 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1060 while (help
[len
] == ' ')
1068 /* Print help for a specific front-end, etc. */
1070 print_filtered_help (unsigned int include_flags
,
1071 unsigned int exclude_flags
,
1072 unsigned int any_flags
,
1073 unsigned int columns
,
1074 struct gcc_options
*opts
,
1075 unsigned int lang_mask
)
1080 bool displayed
= false;
1083 if (include_flags
== CL_PARAMS
)
1085 for (i
= 0; i
< LAST_PARAM
; i
++)
1087 const char *param
= compiler_params
[i
].option
;
1089 help
= compiler_params
[i
].help
;
1090 if (help
== NULL
|| *help
== '\0')
1092 if (exclude_flags
& CL_UNDOCUMENTED
)
1094 help
= undocumented_msg
;
1097 /* Get the translation. */
1100 if (!opts
->x_quiet_flag
)
1102 snprintf (new_help
, sizeof (new_help
),
1103 _("default %d minimum %d maximum %d"),
1104 compiler_params
[i
].default_value
,
1105 compiler_params
[i
].min_value
,
1106 compiler_params
[i
].max_value
);
1109 wrap_help (help
, param
, strlen (param
), columns
);
1115 if (!opts
->x_help_printed
)
1116 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1118 if (!opts
->x_help_enum_printed
)
1119 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1121 for (i
= 0; i
< cl_options_count
; i
++)
1123 const struct cl_option
*option
= cl_options
+ i
;
1128 if (include_flags
== 0
1129 || ((option
->flags
& include_flags
) != include_flags
))
1131 if ((option
->flags
& any_flags
) == 0)
1135 /* Skip unwanted switches. */
1136 if ((option
->flags
& exclude_flags
) != 0)
1139 /* The driver currently prints its own help text. */
1140 if ((option
->flags
& CL_DRIVER
) != 0
1141 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1142 | CL_COMMON
| CL_TARGET
)) == 0)
1146 /* Skip switches that have already been printed. */
1147 if (opts
->x_help_printed
[i
])
1150 opts
->x_help_printed
[i
] = true;
1152 help
= option
->help
;
1155 if (exclude_flags
& CL_UNDOCUMENTED
)
1158 help
= undocumented_msg
;
1161 if (option
->alias_target
< N_OPTS
1162 && cl_options
[option
->alias_target
].help
)
1164 if (help
== undocumented_msg
)
1166 /* For undocumented options that are aliases for other options
1167 that are documented, point the reader to the other option in
1168 preference of the former. */
1169 snprintf (new_help
, sizeof new_help
,
1170 _("Same as %s. Use the latter option instead."),
1171 cl_options
[option
->alias_target
].opt_text
);
1175 /* For documented options with aliases, mention the aliased
1176 option's name for reference. */
1177 snprintf (new_help
, sizeof new_help
,
1178 _("%s Same as %s."),
1179 help
, cl_options
[option
->alias_target
].opt_text
);
1185 if (option
->warn_message
)
1187 /* Mention that the use of the option will trigger a warning. */
1188 if (help
== new_help
)
1189 snprintf (new_help
+ strlen (new_help
),
1190 sizeof new_help
- strlen (new_help
),
1191 " %s", _(use_diagnosed_msg
));
1193 snprintf (new_help
, sizeof new_help
,
1194 "%s %s", help
, _(use_diagnosed_msg
));
1199 /* Get the translation. */
1202 /* Find the gap between the name of the
1203 option and its descriptive text. */
1204 tab
= strchr (help
, '\t');
1213 opt
= option
->opt_text
;
1217 /* With the -Q option enabled we change the descriptive text associated
1218 with an option to be an indication of its current setting. */
1219 if (!opts
->x_quiet_flag
)
1221 void *flag_var
= option_flag_var (i
, opts
);
1223 if (len
< (LEFT_COLUMN
+ 2))
1224 strcpy (new_help
, "\t\t");
1226 strcpy (new_help
, "\t");
1228 if (flag_var
!= NULL
1229 && option
->var_type
!= CLVC_DEFER
)
1231 if (option
->flags
& CL_JOINED
)
1233 if (option
->var_type
== CLVC_STRING
)
1235 if (* (const char **) flag_var
!= NULL
)
1236 snprintf (new_help
+ strlen (new_help
),
1237 sizeof (new_help
) - strlen (new_help
),
1238 "%s", * (const char **) flag_var
);
1240 else if (option
->var_type
== CLVC_ENUM
)
1242 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1244 const char *arg
= NULL
;
1246 value
= e
->get (flag_var
);
1247 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1249 arg
= _("[default]");
1250 snprintf (new_help
+ strlen (new_help
),
1251 sizeof (new_help
) - strlen (new_help
),
1255 sprintf (new_help
+ strlen (new_help
),
1256 "%d", * (int *) flag_var
);
1259 strcat (new_help
, option_enabled (i
, opts
)
1260 ? _("[enabled]") : _("[disabled]"));
1266 wrap_help (help
, opt
, len
, columns
);
1269 if (option
->var_type
== CLVC_ENUM
1270 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1271 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1276 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1279 printf (_(" No options with the desired characteristics were found\n"));
1284 /* PR 31349: Tell the user how to see all of the
1285 options supported by a specific front end. */
1286 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1287 if ((1U << i
) & langs
)
1288 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1289 lang_names
[i
], lang_names
[i
]);
1293 else if (! displayed
)
1294 printf (_(" All options with the desired characteristics have already been displayed\n"));
1298 /* Print details of enumerated option arguments, if those
1299 enumerations have help text headings provided. If no help text
1300 is provided, presume that the possible values are listed in the
1301 help text for the relevant options. */
1302 for (i
= 0; i
< cl_enums_count
; i
++)
1304 unsigned int j
, pos
;
1306 if (opts
->x_help_enum_printed
[i
] != 1)
1308 if (cl_enums
[i
].help
== NULL
)
1310 printf (" %s\n ", _(cl_enums
[i
].help
));
1312 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1314 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1316 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1318 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1328 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1333 opts
->x_help_enum_printed
[i
] = 2;
1337 /* Display help for a specified type of option.
1338 The options must have ALL of the INCLUDE_FLAGS set
1339 ANY of the flags in the ANY_FLAGS set
1340 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1341 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1343 print_specific_help (unsigned int include_flags
,
1344 unsigned int exclude_flags
,
1345 unsigned int any_flags
,
1346 struct gcc_options
*opts
,
1347 unsigned int lang_mask
)
1349 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1350 const char * description
= NULL
;
1351 const char * descrip_extra
= "";
1355 /* Sanity check: Make sure that we do not have more
1356 languages than we have bits available to enumerate them. */
1357 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1359 /* If we have not done so already, obtain
1360 the desired maximum width of the output. */
1361 if (opts
->x_help_columns
== 0)
1363 opts
->x_help_columns
= get_terminal_width ();
1364 if (opts
->x_help_columns
== INT_MAX
)
1365 /* Use a reasonable default. */
1366 opts
->x_help_columns
= 80;
1369 /* Decide upon the title for the options that we are going to display. */
1370 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1372 switch (flag
& include_flags
)
1379 description
= _("The following options are target specific");
1382 description
= _("The following options control compiler warning messages");
1384 case CL_OPTIMIZATION
:
1385 description
= _("The following options control optimizations");
1388 description
= _("The following options are language-independent");
1391 description
= _("The --param option recognizes the following as parameters");
1394 if (i
>= cl_lang_count
)
1396 if (exclude_flags
& all_langs_mask
)
1397 description
= _("The following options are specific to just the language ");
1399 description
= _("The following options are supported by the language ");
1400 descrip_extra
= lang_names
[i
];
1405 if (description
== NULL
)
1409 if (include_flags
& CL_UNDOCUMENTED
)
1410 description
= _("The following options are not documented");
1411 else if (include_flags
& CL_SEPARATE
)
1412 description
= _("The following options take separate arguments");
1413 else if (include_flags
& CL_JOINED
)
1414 description
= _("The following options take joined arguments");
1417 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1424 if (any_flags
& all_langs_mask
)
1425 description
= _("The following options are language-related");
1427 description
= _("The following options are language-independent");
1431 printf ("%s%s:\n", description
, descrip_extra
);
1432 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
1433 opts
->x_help_columns
, opts
, lang_mask
);
1436 /* Enable FDO-related flags. */
1439 enable_fdo_optimizations (struct gcc_options
*opts
,
1440 struct gcc_options
*opts_set
,
1443 if (!opts_set
->x_flag_branch_probabilities
)
1444 opts
->x_flag_branch_probabilities
= value
;
1445 if (!opts_set
->x_flag_profile_values
)
1446 opts
->x_flag_profile_values
= value
;
1447 if (!opts_set
->x_flag_unroll_loops
)
1448 opts
->x_flag_unroll_loops
= value
;
1449 if (!opts_set
->x_flag_peel_loops
)
1450 opts
->x_flag_peel_loops
= value
;
1451 if (!opts_set
->x_flag_tracer
)
1452 opts
->x_flag_tracer
= value
;
1453 if (!opts_set
->x_flag_value_profile_transformations
)
1454 opts
->x_flag_value_profile_transformations
= value
;
1455 if (!opts_set
->x_flag_inline_functions
)
1456 opts
->x_flag_inline_functions
= value
;
1457 if (!opts_set
->x_flag_ipa_cp
)
1458 opts
->x_flag_ipa_cp
= value
;
1459 if (!opts_set
->x_flag_ipa_cp_clone
1460 && value
&& opts
->x_flag_ipa_cp
)
1461 opts
->x_flag_ipa_cp_clone
= value
;
1462 if (!opts_set
->x_flag_ipa_bit_cp
1463 && value
&& opts
->x_flag_ipa_cp
)
1464 opts
->x_flag_ipa_bit_cp
= value
;
1465 if (!opts_set
->x_flag_predictive_commoning
)
1466 opts
->x_flag_predictive_commoning
= value
;
1467 if (!opts_set
->x_flag_split_loops
)
1468 opts
->x_flag_split_loops
= value
;
1469 if (!opts_set
->x_flag_unswitch_loops
)
1470 opts
->x_flag_unswitch_loops
= value
;
1471 if (!opts_set
->x_flag_gcse_after_reload
)
1472 opts
->x_flag_gcse_after_reload
= value
;
1473 if (!opts_set
->x_flag_tree_loop_vectorize
1474 && !opts_set
->x_flag_tree_vectorize
)
1475 opts
->x_flag_tree_loop_vectorize
= value
;
1476 if (!opts_set
->x_flag_tree_slp_vectorize
1477 && !opts_set
->x_flag_tree_vectorize
)
1478 opts
->x_flag_tree_slp_vectorize
= value
;
1479 if (!opts_set
->x_flag_vect_cost_model
)
1480 opts
->x_flag_vect_cost_model
= VECT_COST_MODEL_DYNAMIC
;
1481 if (!opts_set
->x_flag_tree_loop_distribute_patterns
)
1482 opts
->x_flag_tree_loop_distribute_patterns
= value
;
1485 /* -f{,no-}sanitize{,-recover}= suboptions. */
1486 const struct sanitizer_opts_s sanitizer_opts
[] =
1488 #define SANITIZER_OPT(name, flags, recover) \
1489 { #name, flags, sizeof #name - 1, recover }
1490 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true),
1491 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
1493 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false),
1494 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false),
1495 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true),
1496 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true),
1497 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true),
1498 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true),
1499 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true),
1500 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false),
1501 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true),
1502 SANITIZER_OPT (return, SANITIZE_RETURN
, false),
1503 SANITIZER_OPT (null
, SANITIZE_NULL
, true),
1504 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true),
1505 SANITIZER_OPT (bool, SANITIZE_BOOL
, true),
1506 SANITIZER_OPT (enum, SANITIZE_ENUM
, true),
1507 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true),
1508 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true),
1509 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true),
1510 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true),
1511 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true),
1512 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true),
1513 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
1515 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true),
1516 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true),
1517 SANITIZER_OPT (all
, ~0U, true),
1518 #undef SANITIZER_OPT
1519 { NULL
, 0U, 0UL, false }
1522 /* A struct for describing a run of chars within a string. */
1524 struct string_fragment
1526 string_fragment (const char *start
, size_t len
)
1527 : m_start (start
), m_len (len
) {}
1529 const char *m_start
;
1533 /* Specialization of edit_distance_traits for string_fragment,
1534 for use by get_closest_sanitizer_option. */
1537 struct edit_distance_traits
<const string_fragment
&>
1539 static size_t get_length (const string_fragment
&fragment
)
1541 return fragment
.m_len
;
1544 static const char *get_string (const string_fragment
&fragment
)
1546 return fragment
.m_start
;
1550 /* Given ARG, an unrecognized sanitizer option, return the best
1551 matching sanitizer option, or NULL if there isn't one.
1552 CODE is OPT_fsanitize_ or OPT_fsanitize_recover_.
1553 VALUE is non-zero for the regular form of the option, zero
1554 for the "no-" form (e.g. "-fno-sanitize-recover="). */
1557 get_closest_sanitizer_option (const string_fragment
&arg
,
1558 enum opt_code code
, int value
)
1560 best_match
<const string_fragment
&, const char*> bm (arg
);
1561 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1563 /* -fsanitize=all is not valid, so don't offer it. */
1564 if (sanitizer_opts
[i
].flag
== ~0U
1565 && code
== OPT_fsanitize_
1569 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
1570 don't offer the non-recoverable options. */
1571 if (!sanitizer_opts
[i
].can_recover
1572 && code
== OPT_fsanitize_recover_
1576 bm
.consider (sanitizer_opts
[i
].name
);
1578 return bm
.get_best_meaningful_candidate ();
1581 /* Parse comma separated sanitizer suboptions from P for option SCODE,
1582 adjust previous FLAGS and return new ones. If COMPLAIN is false,
1583 don't issue diagnostics. */
1586 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
1587 unsigned int flags
, int value
, bool complain
)
1589 enum opt_code code
= (enum opt_code
) scode
;
1594 const char *comma
= strchr (p
, ',');
1606 /* Check to see if the string matches an option class name. */
1607 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1608 if (len
== sanitizer_opts
[i
].len
1609 && memcmp (p
, sanitizer_opts
[i
].name
, len
) == 0)
1611 /* Handle both -fsanitize and -fno-sanitize cases. */
1612 if (value
&& sanitizer_opts
[i
].flag
== ~0U)
1614 if (code
== OPT_fsanitize_
)
1617 error_at (loc
, "-fsanitize=all option is not valid");
1620 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
1621 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
1625 /* Do not enable -fsanitize-recover=unreachable and
1626 -fsanitize-recover=return if -fsanitize-recover=undefined
1628 if (code
== OPT_fsanitize_recover_
1629 && sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
1630 flags
|= (SANITIZE_UNDEFINED
1631 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
1633 flags
|= sanitizer_opts
[i
].flag
;
1636 flags
&= ~sanitizer_opts
[i
].flag
;
1641 if (! found
&& complain
)
1644 = get_closest_sanitizer_option (string_fragment (p
, len
),
1649 "unrecognized argument to -f%ssanitize%s= option: %q.*s;"
1650 " did you mean %qs?",
1652 code
== OPT_fsanitize_
? "" : "-recover",
1653 (int) len
, p
, hint
);
1656 "unrecognized argument to -f%ssanitize%s= option: %q.*s",
1658 code
== OPT_fsanitize_
? "" : "-recover",
1669 /* Handle target- and language-independent options. Return zero to
1670 generate an "unknown option" message. Only options that need
1671 extra handling need to be listed here; if you simply want
1672 DECODED->value assigned to a variable, it happens automatically. */
1675 common_handle_option (struct gcc_options
*opts
,
1676 struct gcc_options
*opts_set
,
1677 const struct cl_decoded_option
*decoded
,
1678 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
1680 const struct cl_option_handlers
*handlers
,
1681 diagnostic_context
*dc
,
1682 void (*target_option_override_hook
) (void))
1684 size_t scode
= decoded
->opt_index
;
1685 const char *arg
= decoded
->arg
;
1686 int value
= decoded
->value
;
1687 enum opt_code code
= (enum opt_code
) scode
;
1689 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
1694 handle_param (opts
, opts_set
, loc
, arg
);
1699 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1700 unsigned int undoc_mask
;
1703 if (lang_mask
== CL_DRIVER
)
1706 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
1709 target_option_override_hook ();
1710 /* First display any single language specific options. */
1711 for (i
= 0; i
< cl_lang_count
; i
++)
1713 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
1715 /* Next display any multi language specific options. */
1716 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
1717 /* Then display any remaining, non-language options. */
1718 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
1720 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
1721 opts
->x_exit_after_options
= true;
1725 case OPT__target_help
:
1726 if (lang_mask
== CL_DRIVER
)
1729 target_option_override_hook ();
1730 print_specific_help (CL_TARGET
, CL_UNDOCUMENTED
, 0, opts
, lang_mask
);
1731 opts
->x_exit_after_options
= true;
1736 const char *a
= arg
;
1737 unsigned int include_flags
= 0;
1738 /* Note - by default we include undocumented options when listing
1739 specific classes. If you only want to see documented options
1740 then add ",^undocumented" to the --help= option. E.g.:
1742 --help=target,^undocumented */
1743 unsigned int exclude_flags
= 0;
1745 if (lang_mask
== CL_DRIVER
)
1748 /* Walk along the argument string, parsing each word in turn.
1750 arg = [^]{word}[,{arg}]
1751 word = {optimizers|target|warnings|undocumented|
1752 params|common|<language>} */
1762 { "optimizers", CL_OPTIMIZATION
},
1763 { "target", CL_TARGET
},
1764 { "warnings", CL_WARNING
},
1765 { "undocumented", CL_UNDOCUMENTED
},
1766 { "params", CL_PARAMS
},
1767 { "joined", CL_JOINED
},
1768 { "separate", CL_SEPARATE
},
1769 { "common", CL_COMMON
},
1772 unsigned int *pflags
;
1774 unsigned int lang_flag
, specific_flag
;
1783 error_at (loc
, "missing argument to %qs", "--help=^");
1786 pflags
= &exclude_flags
;
1789 pflags
= &include_flags
;
1791 comma
= strchr (a
, ',');
1802 /* Check to see if the string matches an option class name. */
1803 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
1804 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
1806 specific_flag
= specifics
[i
].flag
;
1810 /* Check to see if the string matches a language name.
1811 Note - we rely upon the alpha-sorted nature of the entries in
1812 the lang_names array, specifically that shorter names appear
1813 before their longer variants. (i.e. C before C++). That way
1814 when we are attempting to match --help=c for example we will
1815 match with C first and not C++. */
1816 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
1817 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
1819 lang_flag
= 1U << i
;
1823 if (specific_flag
!= 0)
1826 *pflags
|= specific_flag
;
1829 /* The option's argument matches both the start of a
1830 language name and the start of an option class name.
1831 We have a special case for when the user has
1832 specified "--help=c", but otherwise we have to issue
1834 if (strncasecmp (a
, "c", len
) == 0)
1835 *pflags
|= lang_flag
;
1838 "--help argument %q.*s is ambiguous, "
1839 "please be more specific",
1843 else if (lang_flag
!= 0)
1844 *pflags
|= lang_flag
;
1847 "unrecognized argument to --help= option: %q.*s",
1857 target_option_override_hook ();
1858 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
1861 opts
->x_exit_after_options
= true;
1866 if (lang_mask
== CL_DRIVER
)
1869 opts
->x_exit_after_options
= true;
1872 case OPT_fsanitize_
:
1873 opts
->x_flag_sanitize
1874 = parse_sanitizer_options (arg
, loc
, code
,
1875 opts
->x_flag_sanitize
, value
, true);
1877 /* Kernel ASan implies normal ASan but does not yet support
1879 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
1881 maybe_set_param_value (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD
,
1882 0, opts
->x_param_values
,
1883 opts_set
->x_param_values
);
1884 maybe_set_param_value (PARAM_ASAN_GLOBALS
, 0, opts
->x_param_values
,
1885 opts_set
->x_param_values
);
1886 maybe_set_param_value (PARAM_ASAN_STACK
, 0, opts
->x_param_values
,
1887 opts_set
->x_param_values
);
1888 maybe_set_param_value (PARAM_ASAN_USE_AFTER_RETURN
, 0,
1889 opts
->x_param_values
,
1890 opts_set
->x_param_values
);
1894 case OPT_fsanitize_recover_
:
1895 opts
->x_flag_sanitize_recover
1896 = parse_sanitizer_options (arg
, loc
, code
,
1897 opts
->x_flag_sanitize_recover
, value
, true);
1900 case OPT_fasan_shadow_offset_
:
1904 case OPT_fsanitize_address_use_after_scope
:
1905 opts
->x_flag_sanitize_address_use_after_scope
= value
;
1908 case OPT_fsanitize_recover
:
1910 opts
->x_flag_sanitize_recover
1911 |= (SANITIZE_UNDEFINED
| SANITIZE_NONDEFAULT
)
1912 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
1914 opts
->x_flag_sanitize_recover
1915 &= ~(SANITIZE_UNDEFINED
| SANITIZE_NONDEFAULT
);
1922 /* Currently handled in a prescan. */
1926 dc
->warning_as_error_requested
= value
;
1930 if (lang_mask
== CL_DRIVER
)
1933 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
1934 opts
, opts_set
, loc
, dc
);
1937 case OPT_Wlarger_than_
:
1938 opts
->x_larger_than_size
= value
;
1939 opts
->x_warn_larger_than
= value
!= -1;
1942 case OPT_Wfatal_errors
:
1943 dc
->fatal_errors
= value
;
1946 case OPT_Wframe_larger_than_
:
1947 opts
->x_frame_larger_than_size
= value
;
1948 opts
->x_warn_frame_larger_than
= value
!= -1;
1951 case OPT_Wstack_usage_
:
1952 opts
->x_warn_stack_usage
= value
;
1953 opts
->x_flag_stack_usage_info
= value
!= -1;
1956 case OPT_Wstrict_aliasing
:
1957 set_Wstrict_aliasing (opts
, value
);
1960 case OPT_Wstrict_overflow
:
1961 opts
->x_warn_strict_overflow
= (value
1962 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1966 case OPT_Wsystem_headers
:
1967 dc
->dc_warn_system_headers
= value
;
1971 opts
->x_flag_gen_aux_info
= 1;
1974 case OPT_auxbase_strip
:
1976 char *tmp
= xstrdup (arg
);
1977 strip_off_ending (tmp
, strlen (tmp
));
1979 opts
->x_aux_base_name
= tmp
;
1986 decode_d_option (arg
, opts
, loc
, dc
);
1989 case OPT_fcall_used_
:
1990 case OPT_fcall_saved_
:
1998 case OPT_fdbg_cnt_list
:
2000 opts
->x_exit_after_options
= true;
2003 case OPT_fdebug_prefix_map_
:
2007 case OPT_fdiagnostics_show_location_
:
2008 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2011 case OPT_fdiagnostics_show_caret
:
2012 dc
->show_caret
= value
;
2015 case OPT_fdiagnostics_color_
:
2016 diagnostic_color_init (dc
, value
);
2019 case OPT_fdiagnostics_parseable_fixits
:
2020 dc
->parseable_fixits_p
= value
;
2023 case OPT_fdiagnostics_show_option
:
2024 dc
->show_option_requested
= value
;
2031 case OPT_ffast_math
:
2032 set_fast_math_flags (opts
, value
);
2035 case OPT_funsafe_math_optimizations
:
2036 set_unsafe_math_optimizations_flags (opts
, value
);
2043 case OPT_finline_limit_
:
2044 set_param_value ("max-inline-insns-single", value
/ 2,
2045 opts
->x_param_values
, opts_set
->x_param_values
);
2046 set_param_value ("max-inline-insns-auto", value
/ 2,
2047 opts
->x_param_values
, opts_set
->x_param_values
);
2050 case OPT_finstrument_functions_exclude_function_list_
:
2051 add_comma_separated_to_vector
2052 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2055 case OPT_finstrument_functions_exclude_file_list_
:
2056 add_comma_separated_to_vector
2057 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2060 case OPT_fmessage_length_
:
2061 pp_set_line_maximum_length (dc
->printer
, value
);
2062 diagnostic_set_caret_max_width (dc
, value
);
2066 case OPT_fopt_info_
:
2072 const char *p
= arg
;
2073 opts
->x_flag_disable_hsa
= true;
2076 const char *comma
= strchr (p
, ',');
2078 if ((strncmp (p
, "disable", 7) == 0)
2079 && (p
[7] == ',' || p
[7] == '\0'))
2081 opts
->x_flag_disable_hsa
= true;
2085 if ((strncmp (p
, "hsa", 3) == 0)
2086 && (p
[3] == ',' || p
[3] == '\0'))
2089 opts
->x_flag_disable_hsa
= false;
2091 sorry ("HSA has not been enabled during configuration");
2101 #ifndef ACCEL_COMPILER
2102 case OPT_foffload_abi_
:
2103 error_at (loc
, "-foffload-abi option can be specified only for "
2104 "offload compiler");
2108 case OPT_fpack_struct_
:
2109 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2111 "structure alignment must be a small power of two, not %d",
2114 opts
->x_initial_max_fld_align
= value
;
2118 case OPT_fplugin_arg_
:
2122 case OPT_fprofile_use_
:
2123 opts
->x_profile_data_prefix
= xstrdup (arg
);
2124 opts
->x_flag_profile_use
= true;
2126 /* No break here - do -fprofile-use processing. */
2128 case OPT_fprofile_use
:
2129 enable_fdo_optimizations (opts
, opts_set
, value
);
2130 if (!opts_set
->x_flag_profile_reorder_functions
)
2131 opts
->x_flag_profile_reorder_functions
= value
;
2132 /* Indirect call profiling should do all useful transformations
2133 speculative devirtualization does. */
2134 if (!opts_set
->x_flag_devirtualize_speculatively
2135 && opts
->x_flag_value_profile_transformations
)
2136 opts
->x_flag_devirtualize_speculatively
= false;
2139 case OPT_fauto_profile_
:
2140 opts
->x_auto_profile_file
= xstrdup (arg
);
2141 opts
->x_flag_auto_profile
= true;
2143 /* No break here - do -fauto-profile processing. */
2145 case OPT_fauto_profile
:
2146 enable_fdo_optimizations (opts
, opts_set
, value
);
2147 if (!opts_set
->x_flag_profile_correction
)
2148 opts
->x_flag_profile_correction
= value
;
2149 maybe_set_param_value (
2150 PARAM_EARLY_INLINER_MAX_ITERATIONS
, 10,
2151 opts
->x_param_values
, opts_set
->x_param_values
);
2154 case OPT_fprofile_generate_
:
2155 opts
->x_profile_data_prefix
= xstrdup (arg
);
2157 /* No break here - do -fprofile-generate processing. */
2159 case OPT_fprofile_generate
:
2160 if (!opts_set
->x_profile_arc_flag
)
2161 opts
->x_profile_arc_flag
= value
;
2162 if (!opts_set
->x_flag_profile_values
)
2163 opts
->x_flag_profile_values
= value
;
2164 if (!opts_set
->x_flag_inline_functions
)
2165 opts
->x_flag_inline_functions
= value
;
2166 if (!opts_set
->x_flag_ipa_bit_cp
)
2167 opts
->x_flag_ipa_bit_cp
= value
;
2168 /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
2169 quadratic. Disable the pass until better memory representation
2171 if (!opts_set
->x_flag_ipa_reference
)
2172 opts
->x_flag_ipa_reference
= false;
2175 case OPT_ftree_vectorize
:
2176 if (!opts_set
->x_flag_tree_loop_vectorize
)
2177 opts
->x_flag_tree_loop_vectorize
= value
;
2178 if (!opts_set
->x_flag_tree_slp_vectorize
)
2179 opts
->x_flag_tree_slp_vectorize
= value
;
2181 case OPT_fshow_column
:
2182 dc
->show_column
= value
;
2185 case OPT_frandom_seed
:
2186 /* The real switch is -fno-random-seed. */
2192 case OPT_frandom_seed_
:
2196 case OPT_fsched_verbose_
:
2197 #ifdef INSN_SCHEDULING
2198 /* Handled with Var in common.opt. */
2204 case OPT_fsched_stalled_insns_
:
2205 opts
->x_flag_sched_stalled_insns
= value
;
2206 if (opts
->x_flag_sched_stalled_insns
== 0)
2207 opts
->x_flag_sched_stalled_insns
= -1;
2210 case OPT_fsched_stalled_insns_dep_
:
2211 opts
->x_flag_sched_stalled_insns_dep
= value
;
2214 case OPT_fstack_check_
:
2215 if (!strcmp (arg
, "no"))
2216 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
2217 else if (!strcmp (arg
, "generic"))
2218 /* This is the old stack checking method. */
2219 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2220 ? FULL_BUILTIN_STACK_CHECK
2221 : GENERIC_STACK_CHECK
;
2222 else if (!strcmp (arg
, "specific"))
2223 /* This is the new stack checking method. */
2224 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2225 ? FULL_BUILTIN_STACK_CHECK
2226 : STACK_CHECK_STATIC_BUILTIN
2227 ? STATIC_BUILTIN_STACK_CHECK
2228 : GENERIC_STACK_CHECK
;
2230 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
2233 case OPT_fstack_limit
:
2234 /* The real switch is -fno-stack-limit. */
2240 case OPT_fstack_limit_register_
:
2241 case OPT_fstack_limit_symbol_
:
2245 case OPT_fstack_usage
:
2246 opts
->x_flag_stack_usage
= value
;
2247 opts
->x_flag_stack_usage_info
= value
!= 0;
2251 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
2256 set_debug_level (SDB_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2260 if (arg
&& strlen (arg
) != 0)
2262 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
2263 "use %<-gdwarf-%s%> for DWARF version "
2264 "or %<-gdwarf -g%s%> for debug level", arg
, arg
, arg
);
2268 value
= opts
->x_dwarf_version
;
2272 if (value
< 2 || value
> 5)
2273 error_at (loc
, "dwarf version %d is not supported", value
);
2275 opts
->x_dwarf_version
= value
;
2276 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
2279 case OPT_gsplit_dwarf
:
2280 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, "", opts
, opts_set
,
2285 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
2290 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
, opts
, opts_set
,
2295 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2300 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
, opts
, opts_set
,
2306 /* Handled completely via specs. */
2309 case OPT_pedantic_errors
:
2310 dc
->pedantic_errors
= 1;
2311 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
2313 handlers
, opts
, opts_set
,
2318 opts
->x_flag_lto
= value
? "" : NULL
;
2322 dc
->dc_inhibit_warnings
= true;
2325 case OPT_fmax_errors_
:
2326 dc
->max_errors
= value
;
2329 case OPT_fuse_ld_bfd
:
2330 case OPT_fuse_ld_gold
:
2331 case OPT_fuse_linker_plugin
:
2332 /* No-op. Used by the driver and passed to us because it starts with f.*/
2337 opts
->x_flag_trapv
= 0;
2342 opts
->x_flag_wrapv
= 0;
2346 opts
->x_flag_ipa_icf_functions
= value
;
2347 opts
->x_flag_ipa_icf_variables
= value
;
2351 /* If the flag was handled in a standard way, assume the lack of
2352 processing here is intentional. */
2353 gcc_assert (option_flag_var (scode
, opts
));
2357 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
2362 /* Handle --param NAME=VALUE. */
2364 handle_param (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2365 location_t loc
, const char *carg
)
2370 arg
= xstrdup (carg
);
2371 equal
= strchr (arg
, '=');
2373 error_at (loc
, "%s: --param arguments should be of the form NAME=VALUE",
2379 enum compiler_param index
;
2380 if (!find_param (arg
, &index
))
2382 const char *suggestion
= find_param_fuzzy (arg
);
2384 error_at (loc
, "invalid --param name %qs; did you mean %qs?",
2387 error_at (loc
, "invalid --param name %qs", arg
);
2391 if (!param_string_value_p (index
, equal
+ 1, &value
))
2392 value
= integral_argument (equal
+ 1);
2395 error_at (loc
, "invalid --param value %qs", equal
+ 1);
2397 set_param_value (arg
, value
,
2398 opts
->x_param_values
, opts_set
->x_param_values
);
2405 /* Used to set the level of strict aliasing warnings in OPTS,
2406 when no level is specified (i.e., when -Wstrict-aliasing, and not
2407 -Wstrict-aliasing=level was given).
2408 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2409 and 0 otherwise. After calling this function, wstrict_aliasing will be
2410 set to the default value of -Wstrict_aliasing=level, currently 3. */
2412 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
2414 gcc_assert (onoff
== 0 || onoff
== 1);
2416 opts
->x_warn_strict_aliasing
= 3;
2418 opts
->x_warn_strict_aliasing
= 0;
2421 /* The following routines are useful in setting all the flags that
2422 -ffast-math and -fno-fast-math imply. */
2424 set_fast_math_flags (struct gcc_options
*opts
, int set
)
2426 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
2428 opts
->x_flag_unsafe_math_optimizations
= set
;
2429 set_unsafe_math_optimizations_flags (opts
, set
);
2431 if (!opts
->frontend_set_flag_finite_math_only
)
2432 opts
->x_flag_finite_math_only
= set
;
2433 if (!opts
->frontend_set_flag_errno_math
)
2434 opts
->x_flag_errno_math
= !set
;
2437 if (opts
->frontend_set_flag_excess_precision_cmdline
2438 == EXCESS_PRECISION_DEFAULT
)
2439 opts
->x_flag_excess_precision_cmdline
2440 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
2441 if (!opts
->frontend_set_flag_signaling_nans
)
2442 opts
->x_flag_signaling_nans
= 0;
2443 if (!opts
->frontend_set_flag_rounding_math
)
2444 opts
->x_flag_rounding_math
= 0;
2445 if (!opts
->frontend_set_flag_cx_limited_range
)
2446 opts
->x_flag_cx_limited_range
= 1;
2450 /* When -funsafe-math-optimizations is set the following
2451 flags are set as well. */
2453 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
2455 if (!opts
->frontend_set_flag_trapping_math
)
2456 opts
->x_flag_trapping_math
= !set
;
2457 if (!opts
->frontend_set_flag_signed_zeros
)
2458 opts
->x_flag_signed_zeros
= !set
;
2459 if (!opts
->frontend_set_flag_associative_math
)
2460 opts
->x_flag_associative_math
= set
;
2461 if (!opts
->frontend_set_flag_reciprocal_math
)
2462 opts
->x_flag_reciprocal_math
= set
;
2465 /* Return true iff flags in OPTS are set as if -ffast-math. */
2467 fast_math_flags_set_p (const struct gcc_options
*opts
)
2469 return (!opts
->x_flag_trapping_math
2470 && opts
->x_flag_unsafe_math_optimizations
2471 && opts
->x_flag_finite_math_only
2472 && !opts
->x_flag_signed_zeros
2473 && !opts
->x_flag_errno_math
2474 && opts
->x_flag_excess_precision_cmdline
2475 == EXCESS_PRECISION_FAST
);
2478 /* Return true iff flags are set as if -ffast-math but using the flags stored
2479 in the struct cl_optimization structure. */
2481 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
2483 return (!opt
->x_flag_trapping_math
2484 && opt
->x_flag_unsafe_math_optimizations
2485 && opt
->x_flag_finite_math_only
2486 && !opt
->x_flag_signed_zeros
2487 && !opt
->x_flag_errno_math
);
2490 /* Handle a debug output -g switch for options OPTS
2491 (OPTS_SET->x_write_symbols storing whether a debug type was passed
2492 explicitly), location LOC. EXTENDED is true or false to support
2493 extended output (2 is special and means "-ggdb" was given). */
2495 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
,
2496 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2499 opts
->x_use_gnu_debug_info_extensions
= extended
;
2501 if (type
== NO_DEBUG
)
2503 if (opts
->x_write_symbols
== NO_DEBUG
)
2505 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
2509 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
2510 opts
->x_write_symbols
= DWARF2_DEBUG
;
2511 #elif defined DBX_DEBUGGING_INFO
2512 opts
->x_write_symbols
= DBX_DEBUG
;
2516 if (opts
->x_write_symbols
== NO_DEBUG
)
2517 warning_at (loc
, 0, "target system does not support debug output");
2522 /* Does it conflict with an already selected type? */
2523 if (opts_set
->x_write_symbols
!= NO_DEBUG
2524 && opts
->x_write_symbols
!= NO_DEBUG
2525 && type
!= opts
->x_write_symbols
)
2526 error_at (loc
, "debug format %qs conflicts with prior selection",
2527 debug_type_names
[type
]);
2528 opts
->x_write_symbols
= type
;
2529 opts_set
->x_write_symbols
= type
;
2532 /* A debug flag without a level defaults to level 2.
2533 If off or at level 1, set it to level 2, but if already
2534 at level 3, don't lower it. */
2537 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
2538 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
2542 int argval
= integral_argument (arg
);
2544 error_at (loc
, "unrecognized debug output level %qs", arg
);
2545 else if (argval
> 3)
2546 error_at (loc
, "debug output level %qs is too high", arg
);
2548 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
2552 /* Arrange to dump core on error for diagnostic context DC. (The
2553 regular error message is still printed first, except in the case of
2557 setup_core_dumping (diagnostic_context
*dc
)
2560 signal (SIGABRT
, SIG_DFL
);
2562 #if defined(HAVE_SETRLIMIT)
2565 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
2566 fatal_error (input_location
, "getting core file size maximum limit: %m");
2567 rlim
.rlim_cur
= rlim
.rlim_max
;
2568 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
2569 fatal_error (input_location
,
2570 "setting core file size limit to maximum: %m");
2573 diagnostic_abort_on_error (dc
);
2576 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
2577 diagnostic context DC. */
2580 decode_d_option (const char *arg
, struct gcc_options
*opts
,
2581 location_t loc
, diagnostic_context
*dc
)
2589 opts
->x_flag_debug_asm
= 1;
2592 opts
->x_flag_print_asm_name
= 1;
2595 opts
->x_flag_dump_rtl_in_asm
= 1;
2596 opts
->x_flag_print_asm_name
= 1;
2599 opts
->x_rtl_dump_and_exit
= 1;
2601 case 'D': /* These are handled by the preprocessor. */
2608 setup_core_dumping (dc
);
2611 opts
->x_flag_dump_all_passed
= true;
2615 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
2620 /* Enable (or disable if VALUE is 0) a warning option ARG (language
2621 mask LANG_MASK, option handlers HANDLERS) as an error for option
2622 structures OPTS and OPTS_SET, diagnostic context DC (possibly
2623 NULL), location LOC. This is used by -Werror=. */
2626 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
2627 const struct cl_option_handlers
*handlers
,
2628 struct gcc_options
*opts
,
2629 struct gcc_options
*opts_set
,
2630 location_t loc
, diagnostic_context
*dc
)
2635 new_option
= XNEWVEC (char, strlen (arg
) + 2);
2636 new_option
[0] = 'W';
2637 strcpy (new_option
+ 1, arg
);
2638 option_index
= find_opt (new_option
, lang_mask
);
2639 if (option_index
== OPT_SPECIAL_unknown
)
2640 error_at (loc
, "-Werror=%s: no option -%s", arg
, new_option
);
2641 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
2642 error_at (loc
, "-Werror=%s: -%s is not an option that controls warnings",
2646 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
2647 const char *arg
= NULL
;
2649 if (cl_options
[option_index
].flags
& CL_JOINED
)
2650 arg
= new_option
+ cl_options
[option_index
].opt_len
;
2651 control_warning_option (option_index
, (int) kind
, arg
, value
,
2653 handlers
, opts
, opts_set
, dc
);
2658 /* Return malloced memory for the name of the option OPTION_INDEX
2659 which enabled a diagnostic (context CONTEXT), originally of type
2660 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2664 option_name (diagnostic_context
*context
, int option_index
,
2665 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
2669 /* A warning classified as an error. */
2670 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
2671 && diag_kind
== DK_ERROR
)
2672 return concat (cl_options
[OPT_Werror_
].opt_text
,
2673 /* Skip over "-W". */
2674 cl_options
[option_index
].opt_text
+ 2,
2676 /* A warning with option. */
2678 return xstrdup (cl_options
[option_index
].opt_text
);
2680 /* A warning without option classified as an error. */
2681 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
2682 || diag_kind
== DK_WARNING
)
2683 && context
->warning_as_error_requested
)
2684 return xstrdup (cl_options
[OPT_Werror
].opt_text
);