1 /* Command line option handling.
2 Copyright (C) 2002-2018 Free Software Foundation, Inc.
3 Contributed by Neil Booth.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
29 #include "diagnostic.h"
30 #include "opts-diagnostic.h"
31 #include "insn-attr-common.h"
32 #include "common/common-target.h"
33 #include "spellcheck.h"
35 static void set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
);
37 /* Indexed by enum debug_info_type. */
38 const char *const debug_type_names
[] =
40 "none", "stabs", "dwarf-2", "xcoff", "vms"
43 /* Parse the -femit-struct-debug-detailed option value
44 and set the flag variables. */
46 #define MATCH( prefix, string ) \
47 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
48 ? ((string += sizeof prefix - 1), 1) : 0)
51 set_struct_debug_option (struct gcc_options
*opts
, location_t loc
,
54 /* various labels for comparison */
55 static const char dfn_lbl
[] = "dfn:", dir_lbl
[] = "dir:", ind_lbl
[] = "ind:";
56 static const char ord_lbl
[] = "ord:", gen_lbl
[] = "gen:";
57 static const char none_lbl
[] = "none", any_lbl
[] = "any";
58 static const char base_lbl
[] = "base", sys_lbl
[] = "sys";
60 enum debug_struct_file files
= DINFO_STRUCT_FILE_ANY
;
61 /* Default is to apply to as much as possible. */
62 enum debug_info_usage usage
= DINFO_USAGE_NUM_ENUMS
;
66 if (MATCH (dfn_lbl
, spec
))
67 usage
= DINFO_USAGE_DFN
;
68 else if (MATCH (dir_lbl
, spec
))
69 usage
= DINFO_USAGE_DIR_USE
;
70 else if (MATCH (ind_lbl
, spec
))
71 usage
= DINFO_USAGE_IND_USE
;
73 /* Generics or not? */
74 if (MATCH (ord_lbl
, spec
))
76 else if (MATCH (gen_lbl
, spec
))
79 /* What allowable environment? */
80 if (MATCH (none_lbl
, spec
))
81 files
= DINFO_STRUCT_FILE_NONE
;
82 else if (MATCH (any_lbl
, spec
))
83 files
= DINFO_STRUCT_FILE_ANY
;
84 else if (MATCH (sys_lbl
, spec
))
85 files
= DINFO_STRUCT_FILE_SYS
;
86 else if (MATCH (base_lbl
, spec
))
87 files
= DINFO_STRUCT_FILE_BASE
;
90 "argument %qs to %<-femit-struct-debug-detailed%> "
94 /* Effect the specification. */
95 if (usage
== DINFO_USAGE_NUM_ENUMS
)
99 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DFN
] = files
;
100 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
] = files
;
101 opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
] = files
;
105 opts
->x_debug_struct_generic
[DINFO_USAGE_DFN
] = files
;
106 opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
] = files
;
107 opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
] = files
;
113 opts
->x_debug_struct_ordinary
[usage
] = files
;
115 opts
->x_debug_struct_generic
[usage
] = files
;
119 set_struct_debug_option (opts
, loc
, spec
+1);
122 /* No more -femit-struct-debug-detailed specifications.
126 "argument %qs to %<-femit-struct-debug-detailed%> unknown",
128 if (opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
]
129 < opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
]
130 || opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
]
131 < opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
])
133 "%<-femit-struct-debug-detailed=dir:...%> must allow "
134 "at least as much as "
135 "%<-femit-struct-debug-detailed=ind:...%>");
139 /* Strip off a legitimate source ending from the input string NAME of
140 length LEN. Rather than having to know the names used by all of
141 our front ends, we strip off an ending of a period followed by
142 up to fource characters. (C++ uses ".cpp".) */
145 strip_off_ending (char *name
, int len
)
148 for (i
= 2; i
< 5 && len
> i
; i
++)
150 if (name
[len
- i
] == '.')
152 name
[len
- i
] = '\0';
158 /* Find the base name of a path, stripping off both directories and
159 a single final extension. */
161 base_of_path (const char *path
, const char **base_out
)
163 const char *base
= path
;
165 const char *p
= path
;
169 if (IS_DIR_SEPARATOR (c
))
184 /* What to print when a switch has no documentation. */
185 static const char undocumented_msg
[] = N_("This option lacks documentation.");
186 static const char use_diagnosed_msg
[] = N_("Uses of this option are diagnosed.");
188 typedef char *char_p
; /* For DEF_VEC_P. */
190 static void handle_param (struct gcc_options
*opts
,
191 struct gcc_options
*opts_set
, location_t loc
,
193 static void set_debug_level (enum debug_info_type type
, int extended
,
194 const char *arg
, struct gcc_options
*opts
,
195 struct gcc_options
*opts_set
,
197 static void set_fast_math_flags (struct gcc_options
*opts
, int set
);
198 static void decode_d_option (const char *arg
, struct gcc_options
*opts
,
199 location_t loc
, diagnostic_context
*dc
);
200 static void set_unsafe_math_optimizations_flags (struct gcc_options
*opts
,
202 static void enable_warning_as_error (const char *arg
, int value
,
203 unsigned int lang_mask
,
204 const struct cl_option_handlers
*handlers
,
205 struct gcc_options
*opts
,
206 struct gcc_options
*opts_set
,
208 diagnostic_context
*dc
);
210 /* Handle a back-end option; arguments and return value as for
214 target_handle_option (struct gcc_options
*opts
,
215 struct gcc_options
*opts_set
,
216 const struct cl_decoded_option
*decoded
,
217 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
219 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
220 diagnostic_context
*dc
, void (*) (void))
222 gcc_assert (dc
== global_dc
);
223 gcc_assert (kind
== DK_UNSPECIFIED
);
224 return targetm_common
.handle_option (opts
, opts_set
, decoded
, loc
);
227 /* Add comma-separated strings to a char_p vector. */
230 add_comma_separated_to_vector (void **pvec
, const char *arg
)
236 vec
<char_p
> *v
= (vec
<char_p
> *) *pvec
;
238 vec_check_alloc (v
, 1);
240 /* We never free this string. */
253 v
->safe_push (token_start
);
256 if (*r
== '\\' && r
[1] == ',')
264 if (*token_start
!= '\0')
265 v
->safe_push (token_start
);
270 /* Initialize opts_obstack. */
273 init_opts_obstack (void)
275 gcc_obstack_init (&opts_obstack
);
278 /* Initialize OPTS and OPTS_SET before using them in parsing options. */
281 init_options_struct (struct gcc_options
*opts
, struct gcc_options
*opts_set
)
283 size_t num_params
= get_num_compiler_params ();
285 /* Ensure that opts_obstack has already been initialized by the time
286 that we initialize any gcc_options instances (PR jit/68446). */
287 gcc_assert (opts_obstack
.chunk_size
> 0);
289 *opts
= global_options_init
;
292 memset (opts_set
, 0, sizeof (*opts_set
));
294 opts
->x_param_values
= XNEWVEC (int, num_params
);
297 opts_set
->x_param_values
= XCNEWVEC (int, num_params
);
299 init_param_values (opts
->x_param_values
);
301 /* Initialize whether `char' is signed. */
302 opts
->x_flag_signed_char
= DEFAULT_SIGNED_CHAR
;
303 /* Set this to a special "uninitialized" value. The actual default
304 is set after target options have been processed. */
305 opts
->x_flag_short_enums
= 2;
307 /* Initialize target_flags before default_options_optimization
308 so the latter can modify it. */
309 opts
->x_target_flags
= targetm_common
.default_target_flags
;
311 /* Some targets have ABI-specified unwind tables. */
312 opts
->x_flag_unwind_tables
= targetm_common
.unwind_tables_default
;
314 /* Some targets have other target-specific initialization. */
315 targetm_common
.option_init_struct (opts
);
318 /* Release any allocations owned by OPTS. */
321 finalize_options_struct (struct gcc_options
*opts
)
323 XDELETEVEC (opts
->x_param_values
);
326 /* If indicated by the optimization level LEVEL (-Os if SIZE is set,
327 -Ofast if FAST is set, -Og if DEBUG is set), apply the option DEFAULT_OPT
328 to OPTS and OPTS_SET, diagnostic context DC, location LOC, with language
329 mask LANG_MASK and option handlers HANDLERS. */
332 maybe_default_option (struct gcc_options
*opts
,
333 struct gcc_options
*opts_set
,
334 const struct default_options
*default_opt
,
335 int level
, bool size
, bool fast
, bool debug
,
336 unsigned int lang_mask
,
337 const struct cl_option_handlers
*handlers
,
339 diagnostic_context
*dc
)
341 const struct cl_option
*option
= &cl_options
[default_opt
->opt_index
];
345 gcc_assert (level
== 2);
347 gcc_assert (level
== 3);
349 gcc_assert (level
== 1);
351 switch (default_opt
->levels
)
357 case OPT_LEVELS_0_ONLY
:
358 enabled
= (level
== 0);
361 case OPT_LEVELS_1_PLUS
:
362 enabled
= (level
>= 1);
365 case OPT_LEVELS_1_PLUS_SPEED_ONLY
:
366 enabled
= (level
>= 1 && !size
&& !debug
);
369 case OPT_LEVELS_1_PLUS_NOT_DEBUG
:
370 enabled
= (level
>= 1 && !debug
);
373 case OPT_LEVELS_2_PLUS
:
374 enabled
= (level
>= 2);
377 case OPT_LEVELS_2_PLUS_SPEED_ONLY
:
378 enabled
= (level
>= 2 && !size
&& !debug
);
381 case OPT_LEVELS_3_PLUS
:
382 enabled
= (level
>= 3);
385 case OPT_LEVELS_3_PLUS_AND_SIZE
:
386 enabled
= (level
>= 3 || size
);
389 case OPT_LEVELS_SIZE
:
393 case OPT_LEVELS_FAST
:
397 case OPT_LEVELS_NONE
:
403 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
404 default_opt
->arg
, default_opt
->value
,
405 lang_mask
, DK_UNSPECIFIED
, loc
,
407 else if (default_opt
->arg
== NULL
408 && !option
->cl_reject_negative
)
409 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
410 default_opt
->arg
, !default_opt
->value
,
411 lang_mask
, DK_UNSPECIFIED
, loc
,
415 /* As indicated by the optimization level LEVEL (-Os if SIZE is set,
416 -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
417 OPTS and OPTS_SET, diagnostic context DC, location LOC, with
418 language mask LANG_MASK and option handlers HANDLERS. */
421 maybe_default_options (struct gcc_options
*opts
,
422 struct gcc_options
*opts_set
,
423 const struct default_options
*default_opts
,
424 int level
, bool size
, bool fast
, bool debug
,
425 unsigned int lang_mask
,
426 const struct cl_option_handlers
*handlers
,
428 diagnostic_context
*dc
)
432 for (i
= 0; default_opts
[i
].levels
!= OPT_LEVELS_NONE
; i
++)
433 maybe_default_option (opts
, opts_set
, &default_opts
[i
],
434 level
, size
, fast
, debug
,
435 lang_mask
, handlers
, loc
, dc
);
438 /* Table of options enabled by default at different levels.
439 Please keep this list sorted by level and alphabetized within
440 each level; this makes it easier to keep the documentation
443 static const struct default_options default_options_table
[] =
445 /* -O1 and -Og optimizations. */
446 { OPT_LEVELS_1_PLUS
, OPT_fcombine_stack_adjustments
, NULL
, 1 },
447 { OPT_LEVELS_1_PLUS
, OPT_fcompare_elim
, NULL
, 1 },
448 { OPT_LEVELS_1_PLUS
, OPT_fcprop_registers
, NULL
, 1 },
449 { OPT_LEVELS_1_PLUS
, OPT_fdefer_pop
, NULL
, 1 },
450 { OPT_LEVELS_1_PLUS
, OPT_fforward_propagate
, NULL
, 1 },
451 { OPT_LEVELS_1_PLUS
, OPT_fguess_branch_probability
, NULL
, 1 },
452 { OPT_LEVELS_1_PLUS
, OPT_fipa_profile
, NULL
, 1 },
453 { OPT_LEVELS_1_PLUS
, OPT_fipa_pure_const
, NULL
, 1 },
454 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference
, NULL
, 1 },
455 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference_addressable
, NULL
, 1 },
456 { OPT_LEVELS_1_PLUS
, OPT_fmerge_constants
, NULL
, 1 },
457 { OPT_LEVELS_1_PLUS
, OPT_fomit_frame_pointer
, NULL
, 1 },
458 { OPT_LEVELS_1_PLUS
, OPT_freorder_blocks
, NULL
, 1 },
459 { OPT_LEVELS_1_PLUS
, OPT_fshrink_wrap
, NULL
, 1 },
460 { OPT_LEVELS_1_PLUS
, OPT_fsplit_wide_types
, NULL
, 1 },
461 { OPT_LEVELS_1_PLUS
, OPT_ftree_builtin_call_dce
, NULL
, 1 },
462 { OPT_LEVELS_1_PLUS
, OPT_ftree_ccp
, NULL
, 1 },
463 { OPT_LEVELS_1_PLUS
, OPT_ftree_ch
, NULL
, 1 },
464 { OPT_LEVELS_1_PLUS
, OPT_ftree_coalesce_vars
, NULL
, 1 },
465 { OPT_LEVELS_1_PLUS
, OPT_ftree_copy_prop
, NULL
, 1 },
466 { OPT_LEVELS_1_PLUS
, OPT_ftree_dce
, NULL
, 1 },
467 { OPT_LEVELS_1_PLUS
, OPT_ftree_dominator_opts
, NULL
, 1 },
468 { OPT_LEVELS_1_PLUS
, OPT_ftree_dse
, NULL
, 1 },
469 { OPT_LEVELS_1_PLUS
, OPT_ftree_fre
, NULL
, 1 },
470 { OPT_LEVELS_1_PLUS
, OPT_ftree_sink
, NULL
, 1 },
471 { OPT_LEVELS_1_PLUS
, OPT_ftree_slsr
, NULL
, 1 },
472 { OPT_LEVELS_1_PLUS
, OPT_ftree_ter
, NULL
, 1 },
474 /* -O1 (and not -Og) optimizations. */
475 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fbranch_count_reg
, NULL
, 1 },
477 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fdelayed_branch
, NULL
, 1 },
479 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion
, NULL
, 1 },
480 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion2
, NULL
, 1 },
481 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_finline_functions_called_once
, NULL
, 1 },
482 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_invariants
, NULL
, 1 },
483 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fssa_phiopt
, NULL
, 1 },
484 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_bit_ccp
, NULL
, 1 },
485 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_sra
, NULL
, 1 },
486 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_pta
, NULL
, 1 },
488 /* -O2 and -Os optimizations. */
489 { OPT_LEVELS_2_PLUS
, OPT_fcaller_saves
, NULL
, 1 },
490 { OPT_LEVELS_2_PLUS
, OPT_fcode_hoisting
, NULL
, 1 },
491 { OPT_LEVELS_2_PLUS
, OPT_fcrossjumping
, NULL
, 1 },
492 { OPT_LEVELS_2_PLUS
, OPT_fcse_follow_jumps
, NULL
, 1 },
493 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize
, NULL
, 1 },
494 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize_speculatively
, NULL
, 1 },
495 { OPT_LEVELS_2_PLUS
, OPT_fexpensive_optimizations
, NULL
, 1 },
496 { OPT_LEVELS_2_PLUS
, OPT_fgcse
, NULL
, 1 },
497 { OPT_LEVELS_2_PLUS
, OPT_fhoist_adjacent_loads
, NULL
, 1 },
498 { OPT_LEVELS_2_PLUS
, OPT_findirect_inlining
, NULL
, 1 },
499 { OPT_LEVELS_2_PLUS
, OPT_finline_small_functions
, NULL
, 1 },
500 { OPT_LEVELS_2_PLUS
, OPT_fipa_bit_cp
, NULL
, 1 },
501 { OPT_LEVELS_2_PLUS
, OPT_fipa_cp
, NULL
, 1 },
502 { OPT_LEVELS_2_PLUS
, OPT_fipa_icf
, NULL
, 1 },
503 { OPT_LEVELS_2_PLUS
, OPT_fipa_ra
, NULL
, 1 },
504 { OPT_LEVELS_2_PLUS
, OPT_fipa_sra
, NULL
, 1 },
505 { OPT_LEVELS_2_PLUS
, OPT_fipa_vrp
, NULL
, 1 },
506 { OPT_LEVELS_2_PLUS
, OPT_fisolate_erroneous_paths_dereference
, NULL
, 1 },
507 { OPT_LEVELS_2_PLUS
, OPT_flra_remat
, NULL
, 1 },
508 { OPT_LEVELS_2_PLUS
, OPT_foptimize_sibling_calls
, NULL
, 1 },
509 { OPT_LEVELS_2_PLUS
, OPT_fpartial_inlining
, NULL
, 1 },
510 { OPT_LEVELS_2_PLUS
, OPT_fpeephole2
, NULL
, 1 },
511 { OPT_LEVELS_2_PLUS
, OPT_freorder_functions
, NULL
, 1 },
512 { OPT_LEVELS_2_PLUS
, OPT_frerun_cse_after_loop
, NULL
, 1 },
513 #ifdef INSN_SCHEDULING
514 { OPT_LEVELS_2_PLUS
, OPT_fschedule_insns2
, NULL
, 1 },
516 { OPT_LEVELS_2_PLUS
, OPT_fstrict_aliasing
, NULL
, 1 },
517 { OPT_LEVELS_2_PLUS
, OPT_fstore_merging
, NULL
, 1 },
518 { OPT_LEVELS_2_PLUS
, OPT_fthread_jumps
, NULL
, 1 },
519 { OPT_LEVELS_2_PLUS
, OPT_ftree_pre
, NULL
, 1 },
520 { OPT_LEVELS_2_PLUS
, OPT_ftree_switch_conversion
, NULL
, 1 },
521 { OPT_LEVELS_2_PLUS
, OPT_ftree_tail_merge
, NULL
, 1 },
522 { OPT_LEVELS_2_PLUS
, OPT_ftree_vrp
, NULL
, 1 },
523 { OPT_LEVELS_2_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_CHEAP
},
525 /* -O2 and -Os optimizations. */
526 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_functions
, NULL
, 1 },
527 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_jumps
, NULL
, 1 },
528 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_labels
, NULL
, 1 },
529 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_loops
, NULL
, 1 },
530 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_foptimize_strlen
, NULL
, 1 },
531 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_freorder_blocks_algorithm_
, NULL
,
532 REORDER_BLOCKS_ALGORITHM_STC
},
533 #ifdef INSN_SCHEDULING
534 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
535 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_fschedule_insns
, NULL
, 1 },
538 /* -O3 and -Os optimizations. */
539 /* Inlining of functions reducing size is a good idea with -Os
540 regardless of them being declared inline. */
541 { OPT_LEVELS_3_PLUS_AND_SIZE
, OPT_finline_functions
, NULL
, 1 },
543 /* -O3 optimizations. */
544 { OPT_LEVELS_3_PLUS
, OPT_fgcse_after_reload
, NULL
, 1 },
545 { OPT_LEVELS_3_PLUS
, OPT_fipa_cp_clone
, NULL
, 1 },
546 { OPT_LEVELS_3_PLUS
, OPT_floop_interchange
, NULL
, 1 },
547 { OPT_LEVELS_3_PLUS
, OPT_floop_unroll_and_jam
, NULL
, 1 },
548 { OPT_LEVELS_3_PLUS
, OPT_fpeel_loops
, NULL
, 1 },
549 { OPT_LEVELS_3_PLUS
, OPT_fpredictive_commoning
, NULL
, 1 },
550 { OPT_LEVELS_3_PLUS
, OPT_fsplit_loops
, NULL
, 1 },
551 { OPT_LEVELS_3_PLUS
, OPT_fsplit_paths
, NULL
, 1 },
552 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribute_patterns
, NULL
, 1 },
553 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribution
, NULL
, 1 },
554 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_vectorize
, NULL
, 1 },
555 { OPT_LEVELS_3_PLUS
, OPT_ftree_partial_pre
, NULL
, 1 },
556 { OPT_LEVELS_3_PLUS
, OPT_ftree_slp_vectorize
, NULL
, 1 },
557 { OPT_LEVELS_3_PLUS
, OPT_funswitch_loops
, NULL
, 1 },
558 { OPT_LEVELS_3_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_DYNAMIC
},
560 /* -Ofast adds optimizations to -O3. */
561 { OPT_LEVELS_FAST
, OPT_ffast_math
, NULL
, 1 },
563 { OPT_LEVELS_NONE
, 0, NULL
, 0 }
566 /* Default the options in OPTS and OPTS_SET based on the optimization
567 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
569 default_options_optimization (struct gcc_options
*opts
,
570 struct gcc_options
*opts_set
,
571 struct cl_decoded_option
*decoded_options
,
572 unsigned int decoded_options_count
,
574 unsigned int lang_mask
,
575 const struct cl_option_handlers
*handlers
,
576 diagnostic_context
*dc
)
580 bool openacc_mode
= false;
582 /* Scan to see what optimization level has been specified. That will
583 determine the default value of many flags. */
584 for (i
= 1; i
< decoded_options_count
; i
++)
586 struct cl_decoded_option
*opt
= &decoded_options
[i
];
587 switch (opt
->opt_index
)
590 if (*opt
->arg
== '\0')
592 opts
->x_optimize
= 1;
593 opts
->x_optimize_size
= 0;
594 opts
->x_optimize_fast
= 0;
595 opts
->x_optimize_debug
= 0;
599 const int optimize_val
= integral_argument (opt
->arg
);
600 if (optimize_val
== -1)
601 error_at (loc
, "argument to %<-O%> should be a non-negative "
602 "integer, %<g%>, %<s%> or %<fast%>");
605 opts
->x_optimize
= optimize_val
;
606 if ((unsigned int) opts
->x_optimize
> 255)
607 opts
->x_optimize
= 255;
608 opts
->x_optimize_size
= 0;
609 opts
->x_optimize_fast
= 0;
610 opts
->x_optimize_debug
= 0;
616 opts
->x_optimize_size
= 1;
618 /* Optimizing for size forces optimize to be 2. */
619 opts
->x_optimize
= 2;
620 opts
->x_optimize_fast
= 0;
621 opts
->x_optimize_debug
= 0;
625 /* -Ofast only adds flags to -O3. */
626 opts
->x_optimize_size
= 0;
627 opts
->x_optimize
= 3;
628 opts
->x_optimize_fast
= 1;
629 opts
->x_optimize_debug
= 0;
633 /* -Og selects optimization level 1. */
634 opts
->x_optimize_size
= 0;
635 opts
->x_optimize
= 1;
636 opts
->x_optimize_fast
= 0;
637 opts
->x_optimize_debug
= 1;
646 /* Ignore other options in this prescan. */
651 maybe_default_options (opts
, opts_set
, default_options_table
,
652 opts
->x_optimize
, opts
->x_optimize_size
,
653 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
654 lang_mask
, handlers
, loc
, dc
);
656 /* -O2 param settings. */
657 opt2
= (opts
->x_optimize
>= 2);
660 && !opts_set
->x_flag_ipa_pta
)
661 opts
->x_flag_ipa_pta
= true;
663 /* Track fields in field-sensitive alias analysis. */
664 maybe_set_param_value
665 (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
,
666 opt2
? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
),
667 opts
->x_param_values
, opts_set
->x_param_values
);
669 /* For -O1 only do loop invariant motion for very small loops. */
670 maybe_set_param_value
671 (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
,
672 opt2
? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
) : 1000,
673 opts
->x_param_values
, opts_set
->x_param_values
);
675 /* At -Ofast, allow store motion to introduce potential race conditions. */
676 maybe_set_param_value
677 (PARAM_ALLOW_STORE_DATA_RACES
,
678 opts
->x_optimize_fast
? 1
679 : default_param_value (PARAM_ALLOW_STORE_DATA_RACES
),
680 opts
->x_param_values
, opts_set
->x_param_values
);
682 if (opts
->x_optimize_size
)
683 /* We want to crossjump as much as possible. */
684 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
, 1,
685 opts
->x_param_values
, opts_set
->x_param_values
);
687 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
,
688 default_param_value (PARAM_MIN_CROSSJUMP_INSNS
),
689 opts
->x_param_values
, opts_set
->x_param_values
);
691 /* Restrict the amount of work combine does at -Og while retaining
692 most of its useful transforms. */
693 if (opts
->x_optimize_debug
)
694 maybe_set_param_value (PARAM_MAX_COMBINE_INSNS
, 2,
695 opts
->x_param_values
, opts_set
->x_param_values
);
697 /* Allow default optimizations to be specified on a per-machine basis. */
698 maybe_default_options (opts
, opts_set
,
699 targetm_common
.option_optimization_table
,
700 opts
->x_optimize
, opts
->x_optimize_size
,
701 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
702 lang_mask
, handlers
, loc
, dc
);
705 /* After all options at LOC have been read into OPTS and OPTS_SET,
706 finalize settings of those options and diagnose incompatible
709 finish_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
712 enum unwind_info_type ui_except
;
714 if (opts
->x_dump_base_name
715 && ! opts
->x_dump_base_name_prefixed
)
717 const char *sep
= opts
->x_dump_base_name
;
720 if (IS_DIR_SEPARATOR (*sep
))
724 /* If dump_base_path contains subdirectories, don't prepend
726 else if (opts
->x_dump_dir_name
)
727 /* We have a DUMP_DIR_NAME, prepend that. */
728 opts
->x_dump_base_name
= opts_concat (opts
->x_dump_dir_name
,
729 opts
->x_dump_base_name
, NULL
);
730 else if (opts
->x_aux_base_name
731 && strcmp (opts
->x_aux_base_name
, HOST_BIT_BUCKET
) != 0)
732 /* AUX_BASE_NAME is set and is not the bit bucket. If it
733 contains a directory component, prepend those directories.
734 Typically this places things in the same directory as the
737 const char *aux_base
;
739 base_of_path (opts
->x_aux_base_name
, &aux_base
);
740 if (opts
->x_aux_base_name
!= aux_base
)
742 int dir_len
= aux_base
- opts
->x_aux_base_name
;
743 char *new_dump_base_name
744 = XOBNEWVEC (&opts_obstack
, char,
745 strlen (opts
->x_dump_base_name
) + dir_len
+ 1);
747 /* Copy directory component from OPTS->X_AUX_BASE_NAME. */
748 memcpy (new_dump_base_name
, opts
->x_aux_base_name
, dir_len
);
749 /* Append existing OPTS->X_DUMP_BASE_NAME. */
750 strcpy (new_dump_base_name
+ dir_len
, opts
->x_dump_base_name
);
751 opts
->x_dump_base_name
= new_dump_base_name
;
755 /* It is definitely prefixed now. */
756 opts
->x_dump_base_name_prefixed
= true;
759 /* Handle related options for unit-at-a-time, toplevel-reorder, and
761 if (!opts
->x_flag_unit_at_a_time
)
763 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
764 error_at (loc
, "section anchors must be disabled when unit-at-a-time "
766 opts
->x_flag_section_anchors
= 0;
767 if (opts
->x_flag_toplevel_reorder
== 1)
768 error_at (loc
, "toplevel reorder must be disabled when unit-at-a-time "
770 opts
->x_flag_toplevel_reorder
= 0;
773 /* -fself-test depends on the state of the compiler prior to
774 compiling anything. Ideally it should be run on an empty source
775 file. However, in case we get run with actual source, assume
776 -fsyntax-only which will inhibit any compiler initialization
777 which may confuse the self tests. */
778 if (opts
->x_flag_self_test
)
779 opts
->x_flag_syntax_only
= 1;
781 if (opts
->x_flag_tm
&& opts
->x_flag_non_call_exceptions
)
782 sorry ("transactional memory is not supported with non-call exceptions");
784 /* Unless the user has asked for section anchors, we disable toplevel
785 reordering at -O0 to disable transformations that might be surprising
786 to end users and to get -fno-toplevel-reorder tested. */
787 if (!opts
->x_optimize
788 && opts
->x_flag_toplevel_reorder
== 2
789 && !(opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
))
791 opts
->x_flag_toplevel_reorder
= 0;
792 opts
->x_flag_section_anchors
= 0;
794 if (!opts
->x_flag_toplevel_reorder
)
796 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
797 error_at (loc
, "section anchors must be disabled when toplevel reorder"
799 opts
->x_flag_section_anchors
= 0;
802 if (!opts
->x_flag_opts_finished
)
804 /* We initialize opts->x_flag_pie to -1 so that targets can set a
806 if (opts
->x_flag_pie
== -1)
808 /* We initialize opts->x_flag_pic to -1 so that we can tell if
809 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
810 if (opts
->x_flag_pic
== -1)
811 opts
->x_flag_pie
= DEFAULT_FLAG_PIE
;
813 opts
->x_flag_pie
= 0;
815 /* If -fPIE or -fpie is used, turn on PIC. */
816 if (opts
->x_flag_pie
)
817 opts
->x_flag_pic
= opts
->x_flag_pie
;
818 else if (opts
->x_flag_pic
== -1)
819 opts
->x_flag_pic
= 0;
820 if (opts
->x_flag_pic
&& !opts
->x_flag_pie
)
821 opts
->x_flag_shlib
= 1;
822 opts
->x_flag_opts_finished
= true;
825 /* We initialize opts->x_flag_stack_protect to -1 so that targets
826 can set a default value. */
827 if (opts
->x_flag_stack_protect
== -1)
828 opts
->x_flag_stack_protect
= DEFAULT_FLAG_SSP
;
830 if (opts
->x_optimize
== 0)
832 /* Inlining does not work if not optimizing,
833 so force it not to be done. */
834 opts
->x_warn_inline
= 0;
835 opts
->x_flag_no_inline
= 1;
838 /* The optimization to partition hot and cold basic blocks into separate
839 sections of the .o and executable files does not work (currently)
840 with exception handling. This is because there is no support for
841 generating unwind info. If opts->x_flag_exceptions is turned on
842 we need to turn off the partitioning optimization. */
844 ui_except
= targetm_common
.except_unwind_info (opts
);
846 if (opts
->x_flag_exceptions
847 && opts
->x_flag_reorder_blocks_and_partition
848 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
850 if (opts_set
->x_flag_reorder_blocks_and_partition
)
852 "%<-freorder-blocks-and-partition%> does not work "
853 "with exceptions on this architecture");
854 opts
->x_flag_reorder_blocks_and_partition
= 0;
855 opts
->x_flag_reorder_blocks
= 1;
858 /* If user requested unwind info, then turn off the partitioning
861 if (opts
->x_flag_unwind_tables
862 && !targetm_common
.unwind_tables_default
863 && opts
->x_flag_reorder_blocks_and_partition
864 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
866 if (opts_set
->x_flag_reorder_blocks_and_partition
)
868 "%<-freorder-blocks-and-partition%> does not support "
869 "unwind info on this architecture");
870 opts
->x_flag_reorder_blocks_and_partition
= 0;
871 opts
->x_flag_reorder_blocks
= 1;
874 /* If the target requested unwind info, then turn off the partitioning
875 optimization with a different message. Likewise, if the target does not
876 support named sections. */
878 if (opts
->x_flag_reorder_blocks_and_partition
879 && (!targetm_common
.have_named_sections
880 || (opts
->x_flag_unwind_tables
881 && targetm_common
.unwind_tables_default
882 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
884 if (opts_set
->x_flag_reorder_blocks_and_partition
)
886 "%<-freorder-blocks-and-partition%> does not work "
887 "on this architecture");
888 opts
->x_flag_reorder_blocks_and_partition
= 0;
889 opts
->x_flag_reorder_blocks
= 1;
893 /* Pipelining of outer loops is only possible when general pipelining
894 capabilities are requested. */
895 if (!opts
->x_flag_sel_sched_pipelining
)
896 opts
->x_flag_sel_sched_pipelining_outer_loops
= 0;
898 if (opts
->x_flag_conserve_stack
)
900 maybe_set_param_value (PARAM_LARGE_STACK_FRAME
, 100,
901 opts
->x_param_values
, opts_set
->x_param_values
);
902 maybe_set_param_value (PARAM_STACK_FRAME_GROWTH
, 40,
903 opts
->x_param_values
, opts_set
->x_param_values
);
906 if (opts
->x_flag_lto
)
909 opts
->x_flag_generate_lto
= 1;
911 /* When generating IL, do not operate in whole-program mode.
912 Otherwise, symbols will be privatized too early, causing link
914 opts
->x_flag_whole_program
= 0;
916 error_at (loc
, "LTO support has not been enabled in this configuration");
918 if (!opts
->x_flag_fat_lto_objects
920 || (opts_set
->x_flag_use_linker_plugin
921 && !opts
->x_flag_use_linker_plugin
)))
923 if (opts_set
->x_flag_fat_lto_objects
)
924 error_at (loc
, "%<-fno-fat-lto-objects%> are supported only with "
926 opts
->x_flag_fat_lto_objects
= 1;
930 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
931 default value if they choose based on other options. */
932 if (opts
->x_flag_split_stack
== -1)
933 opts
->x_flag_split_stack
= 0;
934 else if (opts
->x_flag_split_stack
)
936 if (!targetm_common
.supports_split_stack (true, opts
))
938 error_at (loc
, "%<-fsplit-stack%> is not supported by "
939 "this compiler configuration");
940 opts
->x_flag_split_stack
= 0;
944 /* If stack splitting is turned on, and the user did not explicitly
945 request function partitioning, turn off partitioning, as it
946 confuses the linker when trying to handle partitioned split-stack
947 code that calls a non-split-stack functions. But if partitioning
948 was turned on explicitly just hope for the best. */
949 if (opts
->x_flag_split_stack
950 && opts
->x_flag_reorder_blocks_and_partition
951 && !opts_set
->x_flag_reorder_blocks_and_partition
)
952 opts
->x_flag_reorder_blocks_and_partition
= 0;
954 if (opts
->x_flag_reorder_blocks_and_partition
955 && !opts_set
->x_flag_reorder_functions
)
956 opts
->x_flag_reorder_functions
= 1;
958 /* Tune vectorization related parametees according to cost model. */
959 if (opts
->x_flag_vect_cost_model
== VECT_COST_MODEL_CHEAP
)
961 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS
,
962 6, opts
->x_param_values
, opts_set
->x_param_values
);
963 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS
,
964 0, opts
->x_param_values
, opts_set
->x_param_values
);
965 maybe_set_param_value (PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT
,
966 0, opts
->x_param_values
, opts_set
->x_param_values
);
969 /* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
971 if ((!opts
->x_flag_tree_loop_vectorize
&& !opts
->x_flag_tree_slp_vectorize
)
972 || !opts
->x_flag_tree_loop_if_convert
)
973 maybe_set_param_value (PARAM_MAX_STORES_TO_SINK
, 0,
974 opts
->x_param_values
, opts_set
->x_param_values
);
976 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
977 if (opts
->x_dwarf_split_debug_info
)
978 opts
->x_debug_generate_pub_sections
= 2;
980 if ((opts
->x_flag_sanitize
981 & (SANITIZE_USER_ADDRESS
| SANITIZE_KERNEL_ADDRESS
)) == 0)
983 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_COMPARE
)
985 "%<-fsanitize=pointer-compare%> must be combined with "
986 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
987 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_SUBTRACT
)
989 "%<-fsanitize=pointer-subtract%> must be combined with "
990 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
993 /* Userspace and kernel ASan conflict with each other. */
994 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
995 && (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
))
997 "%<-fsanitize=address%> is incompatible with "
998 "%<-fsanitize=kernel-address%>");
1000 /* And with TSan. */
1001 if ((opts
->x_flag_sanitize
& SANITIZE_ADDRESS
)
1002 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
1004 "%<-fsanitize=address%> and %<-fsanitize=kernel-address%> "
1005 "are incompatible with %<-fsanitize=thread%>");
1007 if ((opts
->x_flag_sanitize
& SANITIZE_LEAK
)
1008 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
1010 "%<-fsanitize=leak%> is incompatible with %<-fsanitize=thread%>");
1012 /* Check error recovery for -fsanitize-recover option. */
1013 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1014 if ((opts
->x_flag_sanitize_recover
& sanitizer_opts
[i
].flag
)
1015 && !sanitizer_opts
[i
].can_recover
)
1016 error_at (loc
, "%<-fsanitize-recover=%s%> is not supported",
1017 sanitizer_opts
[i
].name
);
1019 /* When instrumenting the pointers, we don't want to remove
1020 the null pointer checks. */
1021 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
1022 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
1023 opts
->x_flag_delete_null_pointer_checks
= 0;
1025 /* Aggressive compiler optimizations may cause false negatives. */
1026 if (opts
->x_flag_sanitize
& ~(SANITIZE_LEAK
| SANITIZE_UNREACHABLE
))
1027 opts
->x_flag_aggressive_loop_optimizations
= 0;
1029 /* Enable -fsanitize-address-use-after-scope if address sanitizer is
1031 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
1032 && !opts_set
->x_flag_sanitize_address_use_after_scope
)
1033 opts
->x_flag_sanitize_address_use_after_scope
= true;
1035 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1037 if (opts
->x_flag_sanitize_address_use_after_scope
)
1039 if (opts
->x_flag_stack_reuse
!= SR_NONE
1040 && opts_set
->x_flag_stack_reuse
!= SR_NONE
)
1042 "%<-fsanitize-address-use-after-scope%> requires "
1043 "%<-fstack-reuse=none%> option");
1045 opts
->x_flag_stack_reuse
= SR_NONE
;
1048 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
) && opts
->x_flag_tm
)
1049 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1051 if ((opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) && opts
->x_flag_tm
)
1052 sorry ("transactional memory is not supported with "
1053 "%<-fsanitize=kernel-address%>");
1056 #define LEFT_COLUMN 27
1058 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1059 followed by word-wrapped HELP in a second column. */
1061 wrap_help (const char *help
,
1063 unsigned int item_width
,
1064 unsigned int columns
)
1066 unsigned int col_width
= LEFT_COLUMN
;
1067 unsigned int remaining
, room
, len
;
1069 remaining
= strlen (help
);
1073 room
= columns
- 3 - MAX (col_width
, item_width
);
1082 for (i
= 0; help
[i
]; i
++)
1084 if (i
>= room
&& len
!= remaining
)
1088 else if ((help
[i
] == '-' || help
[i
] == '/')
1089 && help
[i
+ 1] != ' '
1090 && i
> 0 && ISALPHA (help
[i
- 1]))
1095 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1097 while (help
[len
] == ' ')
1105 /* Data structure used to print list of valid option values. */
1107 struct option_help_tuple
1109 option_help_tuple (int code
, vec
<const char *> values
):
1110 m_code (code
), m_values (values
)
1113 /* Code of an option. */
1116 /* List of possible values. */
1117 vec
<const char *> m_values
;
1120 /* Print help for a specific front-end, etc. */
1122 print_filtered_help (unsigned int include_flags
,
1123 unsigned int exclude_flags
,
1124 unsigned int any_flags
,
1125 unsigned int columns
,
1126 struct gcc_options
*opts
,
1127 unsigned int lang_mask
)
1132 bool displayed
= false;
1135 if (include_flags
== CL_PARAMS
)
1137 for (i
= 0; i
< LAST_PARAM
; i
++)
1139 const char *param
= compiler_params
[i
].option
;
1141 help
= compiler_params
[i
].help
;
1142 if (help
== NULL
|| *help
== '\0')
1144 if (exclude_flags
& CL_UNDOCUMENTED
)
1146 help
= undocumented_msg
;
1149 /* Get the translation. */
1152 if (!opts
->x_quiet_flag
)
1154 snprintf (new_help
, sizeof (new_help
),
1155 _("default %d minimum %d maximum %d"),
1156 compiler_params
[i
].default_value
,
1157 compiler_params
[i
].min_value
,
1158 compiler_params
[i
].max_value
);
1161 wrap_help (help
, param
, strlen (param
), columns
);
1167 if (!opts
->x_help_printed
)
1168 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1170 if (!opts
->x_help_enum_printed
)
1171 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1173 auto_vec
<option_help_tuple
> help_tuples
;
1175 for (i
= 0; i
< cl_options_count
; i
++)
1177 const struct cl_option
*option
= cl_options
+ i
;
1182 if (include_flags
== 0
1183 || ((option
->flags
& include_flags
) != include_flags
))
1185 if ((option
->flags
& any_flags
) == 0)
1189 /* Skip unwanted switches. */
1190 if ((option
->flags
& exclude_flags
) != 0)
1193 /* The driver currently prints its own help text. */
1194 if ((option
->flags
& CL_DRIVER
) != 0
1195 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1196 | CL_COMMON
| CL_TARGET
)) == 0)
1200 /* Skip switches that have already been printed. */
1201 if (opts
->x_help_printed
[i
])
1204 opts
->x_help_printed
[i
] = true;
1206 help
= option
->help
;
1209 if (exclude_flags
& CL_UNDOCUMENTED
)
1212 help
= undocumented_msg
;
1215 if (option
->alias_target
< N_OPTS
1216 && cl_options
[option
->alias_target
].help
)
1218 if (help
== undocumented_msg
)
1220 /* For undocumented options that are aliases for other options
1221 that are documented, point the reader to the other option in
1222 preference of the former. */
1223 snprintf (new_help
, sizeof new_help
,
1224 _("Same as %s. Use the latter option instead."),
1225 cl_options
[option
->alias_target
].opt_text
);
1229 /* For documented options with aliases, mention the aliased
1230 option's name for reference. */
1231 snprintf (new_help
, sizeof new_help
,
1232 _("%s Same as %s."),
1233 help
, cl_options
[option
->alias_target
].opt_text
);
1239 if (option
->warn_message
)
1241 /* Mention that the use of the option will trigger a warning. */
1242 if (help
== new_help
)
1243 snprintf (new_help
+ strlen (new_help
),
1244 sizeof new_help
- strlen (new_help
),
1245 " %s", _(use_diagnosed_msg
));
1247 snprintf (new_help
, sizeof new_help
,
1248 "%s %s", help
, _(use_diagnosed_msg
));
1253 /* Get the translation. */
1256 /* Find the gap between the name of the
1257 option and its descriptive text. */
1258 tab
= strchr (help
, '\t');
1267 opt
= option
->opt_text
;
1271 /* With the -Q option enabled we change the descriptive text associated
1272 with an option to be an indication of its current setting. */
1273 if (!opts
->x_quiet_flag
)
1275 void *flag_var
= option_flag_var (i
, opts
);
1277 if (len
< (LEFT_COLUMN
+ 2))
1278 strcpy (new_help
, "\t\t");
1280 strcpy (new_help
, "\t");
1282 if (flag_var
!= NULL
1283 && option
->var_type
!= CLVC_DEFER
)
1285 if (option
->flags
& CL_JOINED
)
1287 if (option
->var_type
== CLVC_STRING
)
1289 if (* (const char **) flag_var
!= NULL
)
1290 snprintf (new_help
+ strlen (new_help
),
1291 sizeof (new_help
) - strlen (new_help
),
1292 "%s", * (const char **) flag_var
);
1294 else if (option
->var_type
== CLVC_ENUM
)
1296 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1298 const char *arg
= NULL
;
1300 value
= e
->get (flag_var
);
1301 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1303 arg
= _("[default]");
1304 snprintf (new_help
+ strlen (new_help
),
1305 sizeof (new_help
) - strlen (new_help
),
1309 sprintf (new_help
+ strlen (new_help
),
1310 "%d", * (int *) flag_var
);
1313 strcat (new_help
, option_enabled (i
, opts
)
1314 ? _("[enabled]") : _("[disabled]"));
1320 if (option
->range_max
!= -1)
1323 snprintf (b
, sizeof (b
), "<%d,%d>", option
->range_min
,
1325 opt
= concat (opt
, b
, NULL
);
1329 wrap_help (help
, opt
, len
, columns
);
1332 if (option
->var_type
== CLVC_ENUM
1333 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1334 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1337 vec
<const char *> option_values
1338 = targetm_common
.get_valid_option_values (i
, NULL
);
1339 if (!option_values
.is_empty ())
1340 help_tuples
.safe_push (option_help_tuple (i
, option_values
));
1346 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1349 printf (_(" No options with the desired characteristics were found\n"));
1354 /* PR 31349: Tell the user how to see all of the
1355 options supported by a specific front end. */
1356 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1357 if ((1U << i
) & langs
)
1358 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1359 lang_names
[i
], lang_names
[i
]);
1363 else if (! displayed
)
1364 printf (_(" All options with the desired characteristics have already been displayed\n"));
1368 /* Print details of enumerated option arguments, if those
1369 enumerations have help text headings provided. If no help text
1370 is provided, presume that the possible values are listed in the
1371 help text for the relevant options. */
1372 for (i
= 0; i
< cl_enums_count
; i
++)
1374 unsigned int j
, pos
;
1376 if (opts
->x_help_enum_printed
[i
] != 1)
1378 if (cl_enums
[i
].help
== NULL
)
1380 printf (" %s\n ", _(cl_enums
[i
].help
));
1382 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1384 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1386 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1388 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1398 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1403 opts
->x_help_enum_printed
[i
] = 2;
1406 for (unsigned i
= 0; i
< help_tuples
.length (); i
++)
1408 const struct cl_option
*option
= cl_options
+ help_tuples
[i
].m_code
;
1409 printf (" Known valid arguments for %s option:\n ", option
->opt_text
);
1410 for (unsigned j
= 0; j
< help_tuples
[i
].m_values
.length (); j
++)
1411 printf (" %s", help_tuples
[i
].m_values
[j
]);
1416 /* Display help for a specified type of option.
1417 The options must have ALL of the INCLUDE_FLAGS set
1418 ANY of the flags in the ANY_FLAGS set
1419 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1420 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1422 print_specific_help (unsigned int include_flags
,
1423 unsigned int exclude_flags
,
1424 unsigned int any_flags
,
1425 struct gcc_options
*opts
,
1426 unsigned int lang_mask
)
1428 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1429 const char * description
= NULL
;
1430 const char * descrip_extra
= "";
1434 /* Sanity check: Make sure that we do not have more
1435 languages than we have bits available to enumerate them. */
1436 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1438 /* If we have not done so already, obtain
1439 the desired maximum width of the output. */
1440 if (opts
->x_help_columns
== 0)
1442 opts
->x_help_columns
= get_terminal_width ();
1443 if (opts
->x_help_columns
== INT_MAX
)
1444 /* Use a reasonable default. */
1445 opts
->x_help_columns
= 80;
1448 /* Decide upon the title for the options that we are going to display. */
1449 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1451 switch (flag
& include_flags
)
1458 description
= _("The following options are target specific");
1461 description
= _("The following options control compiler warning messages");
1463 case CL_OPTIMIZATION
:
1464 description
= _("The following options control optimizations");
1467 description
= _("The following options are language-independent");
1470 description
= _("The --param option recognizes the following as parameters");
1473 if (i
>= cl_lang_count
)
1475 if (exclude_flags
& all_langs_mask
)
1476 description
= _("The following options are specific to just the language ");
1478 description
= _("The following options are supported by the language ");
1479 descrip_extra
= lang_names
[i
];
1484 if (description
== NULL
)
1488 if (include_flags
& CL_UNDOCUMENTED
)
1489 description
= _("The following options are not documented");
1490 else if (include_flags
& CL_SEPARATE
)
1491 description
= _("The following options take separate arguments");
1492 else if (include_flags
& CL_JOINED
)
1493 description
= _("The following options take joined arguments");
1496 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1503 if (any_flags
& all_langs_mask
)
1504 description
= _("The following options are language-related");
1506 description
= _("The following options are language-independent");
1510 printf ("%s%s:\n", description
, descrip_extra
);
1511 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
1512 opts
->x_help_columns
, opts
, lang_mask
);
1515 /* Enable FDO-related flags. */
1518 enable_fdo_optimizations (struct gcc_options
*opts
,
1519 struct gcc_options
*opts_set
,
1522 if (!opts_set
->x_flag_branch_probabilities
)
1523 opts
->x_flag_branch_probabilities
= value
;
1524 if (!opts_set
->x_flag_profile_values
)
1525 opts
->x_flag_profile_values
= value
;
1526 if (!opts_set
->x_flag_unroll_loops
)
1527 opts
->x_flag_unroll_loops
= value
;
1528 if (!opts_set
->x_flag_peel_loops
)
1529 opts
->x_flag_peel_loops
= value
;
1530 if (!opts_set
->x_flag_tracer
)
1531 opts
->x_flag_tracer
= value
;
1532 if (!opts_set
->x_flag_value_profile_transformations
)
1533 opts
->x_flag_value_profile_transformations
= value
;
1534 if (!opts_set
->x_flag_inline_functions
)
1535 opts
->x_flag_inline_functions
= value
;
1536 if (!opts_set
->x_flag_ipa_cp
)
1537 opts
->x_flag_ipa_cp
= value
;
1538 if (!opts_set
->x_flag_ipa_cp_clone
1539 && value
&& opts
->x_flag_ipa_cp
)
1540 opts
->x_flag_ipa_cp_clone
= value
;
1541 if (!opts_set
->x_flag_ipa_bit_cp
1542 && value
&& opts
->x_flag_ipa_cp
)
1543 opts
->x_flag_ipa_bit_cp
= value
;
1544 if (!opts_set
->x_flag_predictive_commoning
)
1545 opts
->x_flag_predictive_commoning
= value
;
1546 if (!opts_set
->x_flag_split_loops
)
1547 opts
->x_flag_split_loops
= value
;
1548 if (!opts_set
->x_flag_unswitch_loops
)
1549 opts
->x_flag_unswitch_loops
= value
;
1550 if (!opts_set
->x_flag_gcse_after_reload
)
1551 opts
->x_flag_gcse_after_reload
= value
;
1552 if (!opts_set
->x_flag_tree_loop_vectorize
)
1553 opts
->x_flag_tree_loop_vectorize
= value
;
1554 if (!opts_set
->x_flag_tree_slp_vectorize
)
1555 opts
->x_flag_tree_slp_vectorize
= value
;
1556 if (!opts_set
->x_flag_vect_cost_model
)
1557 opts
->x_flag_vect_cost_model
= VECT_COST_MODEL_DYNAMIC
;
1558 if (!opts_set
->x_flag_tree_loop_distribute_patterns
)
1559 opts
->x_flag_tree_loop_distribute_patterns
= value
;
1562 /* -f{,no-}sanitize{,-recover}= suboptions. */
1563 const struct sanitizer_opts_s sanitizer_opts
[] =
1565 #define SANITIZER_OPT(name, flags, recover) \
1566 { #name, flags, sizeof #name - 1, recover }
1567 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true),
1568 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
1570 SANITIZER_OPT (pointer
-compare
, SANITIZE_POINTER_COMPARE
, true),
1571 SANITIZER_OPT (pointer
-subtract
, SANITIZE_POINTER_SUBTRACT
, true),
1572 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false),
1573 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false),
1574 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true),
1575 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true),
1576 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true),
1577 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true),
1578 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true),
1579 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false),
1580 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true),
1581 SANITIZER_OPT (return, SANITIZE_RETURN
, false),
1582 SANITIZER_OPT (null
, SANITIZE_NULL
, true),
1583 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true),
1584 SANITIZER_OPT (bool, SANITIZE_BOOL
, true),
1585 SANITIZER_OPT (enum, SANITIZE_ENUM
, true),
1586 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true),
1587 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true),
1588 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true),
1589 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true),
1590 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true),
1591 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true),
1592 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
1594 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true),
1595 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true),
1596 SANITIZER_OPT (pointer
-overflow
, SANITIZE_POINTER_OVERFLOW
, true),
1597 SANITIZER_OPT (builtin
, SANITIZE_BUILTIN
, true),
1598 SANITIZER_OPT (all
, ~0U, true),
1599 #undef SANITIZER_OPT
1600 { NULL
, 0U, 0UL, false }
1603 /* -f{,no-}sanitize-coverage= suboptions. */
1604 const struct sanitizer_opts_s coverage_sanitizer_opts
[] =
1606 #define COVERAGE_SANITIZER_OPT(name, flags) \
1607 { #name, flags, sizeof #name - 1, true }
1608 COVERAGE_SANITIZER_OPT (trace
-pc
, SANITIZE_COV_TRACE_PC
),
1609 COVERAGE_SANITIZER_OPT (trace
-cmp
, SANITIZE_COV_TRACE_CMP
),
1610 #undef COVERAGE_SANITIZER_OPT
1611 { NULL
, 0U, 0UL, false }
1614 /* A struct for describing a run of chars within a string. */
1616 struct string_fragment
1618 string_fragment (const char *start
, size_t len
)
1619 : m_start (start
), m_len (len
) {}
1621 const char *m_start
;
1625 /* Specialization of edit_distance_traits for string_fragment,
1626 for use by get_closest_sanitizer_option. */
1629 struct edit_distance_traits
<const string_fragment
&>
1631 static size_t get_length (const string_fragment
&fragment
)
1633 return fragment
.m_len
;
1636 static const char *get_string (const string_fragment
&fragment
)
1638 return fragment
.m_start
;
1642 /* Given ARG, an unrecognized sanitizer option, return the best
1643 matching sanitizer option, or NULL if there isn't one.
1644 OPTS is array of candidate sanitizer options.
1645 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or
1646 OPT_fsanitize_coverage_.
1647 VALUE is non-zero for the regular form of the option, zero
1648 for the "no-" form (e.g. "-fno-sanitize-recover="). */
1651 get_closest_sanitizer_option (const string_fragment
&arg
,
1652 const struct sanitizer_opts_s
*opts
,
1653 enum opt_code code
, int value
)
1655 best_match
<const string_fragment
&, const char*> bm (arg
);
1656 for (int i
= 0; opts
[i
].name
!= NULL
; ++i
)
1658 /* -fsanitize=all is not valid, so don't offer it. */
1659 if (code
== OPT_fsanitize_
1660 && opts
[i
].flag
== ~0U
1664 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
1665 don't offer the non-recoverable options. */
1666 if (code
== OPT_fsanitize_recover_
1667 && !opts
[i
].can_recover
1671 bm
.consider (opts
[i
].name
);
1673 return bm
.get_best_meaningful_candidate ();
1676 /* Parse comma separated sanitizer suboptions from P for option SCODE,
1677 adjust previous FLAGS and return new ones. If COMPLAIN is false,
1678 don't issue diagnostics. */
1681 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
1682 unsigned int flags
, int value
, bool complain
)
1684 enum opt_code code
= (enum opt_code
) scode
;
1686 const struct sanitizer_opts_s
*opts
;
1687 if (code
== OPT_fsanitize_coverage_
)
1688 opts
= coverage_sanitizer_opts
;
1690 opts
= sanitizer_opts
;
1696 const char *comma
= strchr (p
, ',');
1708 /* Check to see if the string matches an option class name. */
1709 for (i
= 0; opts
[i
].name
!= NULL
; ++i
)
1710 if (len
== opts
[i
].len
&& memcmp (p
, opts
[i
].name
, len
) == 0)
1712 /* Handle both -fsanitize and -fno-sanitize cases. */
1713 if (value
&& opts
[i
].flag
== ~0U)
1715 if (code
== OPT_fsanitize_
)
1718 error_at (loc
, "%<-fsanitize=all%> option is not valid");
1721 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
1722 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
1726 /* Do not enable -fsanitize-recover=unreachable and
1727 -fsanitize-recover=return if -fsanitize-recover=undefined
1729 if (code
== OPT_fsanitize_recover_
1730 && opts
[i
].flag
== SANITIZE_UNDEFINED
)
1731 flags
|= (SANITIZE_UNDEFINED
1732 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
1734 flags
|= opts
[i
].flag
;
1737 flags
&= ~opts
[i
].flag
;
1742 if (! found
&& complain
)
1745 = get_closest_sanitizer_option (string_fragment (p
, len
),
1749 if (code
== OPT_fsanitize_recover_
)
1750 suffix
= "-recover";
1751 else if (code
== OPT_fsanitize_coverage_
)
1752 suffix
= "-coverage";
1758 "unrecognized argument to -f%ssanitize%s= option: %q.*s;"
1759 " did you mean %qs?",
1761 suffix
, (int) len
, p
, hint
);
1764 "unrecognized argument to -f%ssanitize%s= option: %q.*s",
1766 suffix
, (int) len
, p
);
1776 /* Parse string values of no_sanitize attribute passed in VALUE.
1777 Values are separated with comma. */
1780 parse_no_sanitize_attribute (char *value
)
1782 unsigned int flags
= 0;
1784 char *q
= strtok (value
, ",");
1788 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1789 if (strcmp (sanitizer_opts
[i
].name
, q
) == 0)
1791 flags
|= sanitizer_opts
[i
].flag
;
1792 if (sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
1793 flags
|= SANITIZE_UNDEFINED_NONDEFAULT
;
1797 if (sanitizer_opts
[i
].name
== NULL
)
1798 warning (OPT_Wattributes
,
1799 "%<%s%> attribute directive ignored", q
);
1801 q
= strtok (NULL
, ",");
1807 /* Parse -falign-NAME format for a FLAG value. Return individual
1808 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
1809 set, print error message at LOC location. */
1812 parse_and_check_align_values (const char *flag
,
1814 auto_vec
<unsigned> &result_values
,
1818 char *str
= xstrdup (flag
);
1819 for (char *p
= strtok (str
, ":"); p
; p
= strtok (NULL
, ":"))
1822 int v
= strtol (p
, &end
, 10);
1823 if (*end
!= '\0' || v
< 0)
1826 error_at (loc
, "invalid arguments for %<-falign-%s%> option: %qs",
1832 result_values
.safe_push ((unsigned)v
);
1837 /* Check that we have a correct number of values. */
1839 unsigned max_valid_values
= 4;
1841 unsigned max_valid_values
= 2;
1844 if (result_values
.is_empty ()
1845 || result_values
.length () > max_valid_values
)
1848 error_at (loc
, "invalid number of arguments for %<-falign-%s%> "
1849 "option: %qs", name
, flag
);
1853 for (unsigned i
= 0; i
< result_values
.length (); i
++)
1854 if (result_values
[i
] > MAX_CODE_ALIGN_VALUE
)
1857 error_at (loc
, "%<-falign-%s%> is not between 0 and %d",
1858 name
, MAX_CODE_ALIGN_VALUE
);
1865 /* Check that alignment value FLAG for -falign-NAME is valid at a given
1869 check_alignment_argument (location_t loc
, const char *flag
, const char *name
)
1871 auto_vec
<unsigned> align_result
;
1872 parse_and_check_align_values (flag
, name
, align_result
, true, loc
);
1875 /* Handle target- and language-independent options. Return zero to
1876 generate an "unknown option" message. Only options that need
1877 extra handling need to be listed here; if you simply want
1878 DECODED->value assigned to a variable, it happens automatically. */
1881 common_handle_option (struct gcc_options
*opts
,
1882 struct gcc_options
*opts_set
,
1883 const struct cl_decoded_option
*decoded
,
1884 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
1886 const struct cl_option_handlers
*handlers
,
1887 diagnostic_context
*dc
,
1888 void (*target_option_override_hook
) (void))
1890 size_t scode
= decoded
->opt_index
;
1891 const char *arg
= decoded
->arg
;
1892 HOST_WIDE_INT value
= decoded
->value
;
1893 enum opt_code code
= (enum opt_code
) scode
;
1895 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
1900 handle_param (opts
, opts_set
, loc
, arg
);
1905 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1906 unsigned int undoc_mask
;
1909 if (lang_mask
== CL_DRIVER
)
1912 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
1915 target_option_override_hook ();
1916 /* First display any single language specific options. */
1917 for (i
= 0; i
< cl_lang_count
; i
++)
1919 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
1921 /* Next display any multi language specific options. */
1922 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
1923 /* Then display any remaining, non-language options. */
1924 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
1926 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
1927 opts
->x_exit_after_options
= true;
1931 case OPT__target_help
:
1932 if (lang_mask
== CL_DRIVER
)
1935 target_option_override_hook ();
1936 print_specific_help (CL_TARGET
, CL_UNDOCUMENTED
, 0, opts
, lang_mask
);
1937 opts
->x_exit_after_options
= true;
1942 const char *a
= arg
;
1943 unsigned int include_flags
= 0;
1944 /* Note - by default we include undocumented options when listing
1945 specific classes. If you only want to see documented options
1946 then add ",^undocumented" to the --help= option. E.g.:
1948 --help=target,^undocumented */
1949 unsigned int exclude_flags
= 0;
1951 if (lang_mask
== CL_DRIVER
)
1954 /* Walk along the argument string, parsing each word in turn.
1956 arg = [^]{word}[,{arg}]
1957 word = {optimizers|target|warnings|undocumented|
1958 params|common|<language>} */
1968 { "optimizers", CL_OPTIMIZATION
},
1969 { "target", CL_TARGET
},
1970 { "warnings", CL_WARNING
},
1971 { "undocumented", CL_UNDOCUMENTED
},
1972 { "params", CL_PARAMS
},
1973 { "joined", CL_JOINED
},
1974 { "separate", CL_SEPARATE
},
1975 { "common", CL_COMMON
},
1978 unsigned int *pflags
;
1980 unsigned int lang_flag
, specific_flag
;
1989 error_at (loc
, "missing argument to %qs", "--help=^");
1992 pflags
= &exclude_flags
;
1995 pflags
= &include_flags
;
1997 comma
= strchr (a
, ',');
2008 /* Check to see if the string matches an option class name. */
2009 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
2010 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
2012 specific_flag
= specifics
[i
].flag
;
2016 /* Check to see if the string matches a language name.
2017 Note - we rely upon the alpha-sorted nature of the entries in
2018 the lang_names array, specifically that shorter names appear
2019 before their longer variants. (i.e. C before C++). That way
2020 when we are attempting to match --help=c for example we will
2021 match with C first and not C++. */
2022 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
2023 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
2025 lang_flag
= 1U << i
;
2029 if (specific_flag
!= 0)
2032 *pflags
|= specific_flag
;
2035 /* The option's argument matches both the start of a
2036 language name and the start of an option class name.
2037 We have a special case for when the user has
2038 specified "--help=c", but otherwise we have to issue
2040 if (strncasecmp (a
, "c", len
) == 0)
2041 *pflags
|= lang_flag
;
2044 "--help argument %q.*s is ambiguous, "
2045 "please be more specific",
2049 else if (lang_flag
!= 0)
2050 *pflags
|= lang_flag
;
2053 "unrecognized argument to --help= option: %q.*s",
2063 target_option_override_hook ();
2064 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
2067 opts
->x_exit_after_options
= true;
2072 if (lang_mask
== CL_DRIVER
)
2075 opts
->x_exit_after_options
= true;
2078 case OPT__completion_
:
2081 case OPT_fsanitize_
:
2082 opts
->x_flag_sanitize
2083 = parse_sanitizer_options (arg
, loc
, code
,
2084 opts
->x_flag_sanitize
, value
, true);
2086 /* Kernel ASan implies normal ASan but does not yet support
2088 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
2090 maybe_set_param_value (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD
,
2091 0, opts
->x_param_values
,
2092 opts_set
->x_param_values
);
2093 maybe_set_param_value (PARAM_ASAN_GLOBALS
, 0, opts
->x_param_values
,
2094 opts_set
->x_param_values
);
2095 maybe_set_param_value (PARAM_ASAN_STACK
, 0, opts
->x_param_values
,
2096 opts_set
->x_param_values
);
2097 maybe_set_param_value (PARAM_ASAN_PROTECT_ALLOCAS
, 0,
2098 opts
->x_param_values
,
2099 opts_set
->x_param_values
);
2100 maybe_set_param_value (PARAM_ASAN_USE_AFTER_RETURN
, 0,
2101 opts
->x_param_values
,
2102 opts_set
->x_param_values
);
2106 case OPT_fsanitize_recover_
:
2107 opts
->x_flag_sanitize_recover
2108 = parse_sanitizer_options (arg
, loc
, code
,
2109 opts
->x_flag_sanitize_recover
, value
, true);
2112 case OPT_fasan_shadow_offset_
:
2116 case OPT_fsanitize_address_use_after_scope
:
2117 opts
->x_flag_sanitize_address_use_after_scope
= value
;
2120 case OPT_fsanitize_recover
:
2122 opts
->x_flag_sanitize_recover
2123 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)
2124 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2126 opts
->x_flag_sanitize_recover
2127 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2130 case OPT_fsanitize_coverage_
:
2131 opts
->x_flag_sanitize_coverage
2132 = parse_sanitizer_options (arg
, loc
, code
,
2133 opts
->x_flag_sanitize_coverage
, value
, true);
2140 /* Currently handled in a prescan. */
2144 dc
->warning_as_error_requested
= value
;
2148 if (lang_mask
== CL_DRIVER
)
2151 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
2152 opts
, opts_set
, loc
, dc
);
2155 case OPT_Wfatal_errors
:
2156 dc
->fatal_errors
= value
;
2159 case OPT_Wstack_usage_
:
2160 opts
->x_flag_stack_usage_info
= value
!= -1;
2163 case OPT_Wstrict_aliasing
:
2164 set_Wstrict_aliasing (opts
, value
);
2167 case OPT_Wstrict_overflow
:
2168 opts
->x_warn_strict_overflow
= (value
2169 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2173 case OPT_Wsystem_headers
:
2174 dc
->dc_warn_system_headers
= value
;
2178 opts
->x_flag_gen_aux_info
= 1;
2181 case OPT_auxbase_strip
:
2183 char *tmp
= xstrdup (arg
);
2184 strip_off_ending (tmp
, strlen (tmp
));
2186 opts
->x_aux_base_name
= tmp
;
2193 decode_d_option (arg
, opts
, loc
, dc
);
2196 case OPT_fcall_used_
:
2197 case OPT_fcall_saved_
:
2205 case OPT_fdbg_cnt_list
:
2207 opts
->x_exit_after_options
= true;
2210 case OPT_fdebug_prefix_map_
:
2211 case OPT_ffile_prefix_map_
:
2215 case OPT_fdiagnostics_show_location_
:
2216 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2219 case OPT_fdiagnostics_show_caret
:
2220 dc
->show_caret
= value
;
2223 case OPT_fdiagnostics_show_labels
:
2224 dc
->show_labels_p
= value
;
2227 case OPT_fdiagnostics_show_line_numbers
:
2228 dc
->show_line_numbers_p
= value
;
2231 case OPT_fdiagnostics_color_
:
2232 diagnostic_color_init (dc
, value
);
2235 case OPT_fdiagnostics_format_
:
2236 diagnostic_output_format_init (dc
,
2237 (enum diagnostics_output_format
)value
);
2240 case OPT_fdiagnostics_parseable_fixits
:
2241 dc
->parseable_fixits_p
= value
;
2244 case OPT_fdiagnostics_show_option
:
2245 dc
->show_option_requested
= value
;
2248 case OPT_fdiagnostics_minimum_margin_width_
:
2249 dc
->min_margin_width
= value
;
2256 case OPT_ffast_math
:
2257 set_fast_math_flags (opts
, value
);
2260 case OPT_funsafe_math_optimizations
:
2261 set_unsafe_math_optimizations_flags (opts
, value
);
2268 case OPT_finline_limit_
:
2269 set_param_value ("max-inline-insns-single", value
/ 2,
2270 opts
->x_param_values
, opts_set
->x_param_values
);
2271 set_param_value ("max-inline-insns-auto", value
/ 2,
2272 opts
->x_param_values
, opts_set
->x_param_values
);
2275 case OPT_finstrument_functions_exclude_function_list_
:
2276 add_comma_separated_to_vector
2277 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2280 case OPT_finstrument_functions_exclude_file_list_
:
2281 add_comma_separated_to_vector
2282 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2285 case OPT_fmessage_length_
:
2286 pp_set_line_maximum_length (dc
->printer
, value
);
2287 diagnostic_set_caret_max_width (dc
, value
);
2291 case OPT_fopt_info_
:
2297 const char *p
= arg
;
2298 opts
->x_flag_disable_hsa
= true;
2301 const char *comma
= strchr (p
, ',');
2303 if ((strncmp (p
, "disable", 7) == 0)
2304 && (p
[7] == ',' || p
[7] == '\0'))
2306 opts
->x_flag_disable_hsa
= true;
2310 if ((strncmp (p
, "hsa", 3) == 0)
2311 && (p
[3] == ',' || p
[3] == '\0'))
2314 opts
->x_flag_disable_hsa
= false;
2316 sorry ("HSA has not been enabled during configuration");
2326 #ifndef ACCEL_COMPILER
2327 case OPT_foffload_abi_
:
2328 error_at (loc
, "%<-foffload-abi%> option can be specified only for "
2329 "offload compiler");
2333 case OPT_fpack_struct_
:
2334 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2336 "structure alignment must be a small power of two, not %wu",
2339 opts
->x_initial_max_fld_align
= value
;
2343 case OPT_fplugin_arg_
:
2347 case OPT_fprofile_use_
:
2348 opts
->x_profile_data_prefix
= xstrdup (arg
);
2349 opts
->x_flag_profile_use
= true;
2351 /* No break here - do -fprofile-use processing. */
2353 case OPT_fprofile_use
:
2354 enable_fdo_optimizations (opts
, opts_set
, value
);
2355 if (!opts_set
->x_flag_profile_reorder_functions
)
2356 opts
->x_flag_profile_reorder_functions
= value
;
2357 /* Indirect call profiling should do all useful transformations
2358 speculative devirtualization does. */
2359 if (!opts_set
->x_flag_devirtualize_speculatively
2360 && opts
->x_flag_value_profile_transformations
)
2361 opts
->x_flag_devirtualize_speculatively
= false;
2364 case OPT_fauto_profile_
:
2365 opts
->x_auto_profile_file
= xstrdup (arg
);
2366 opts
->x_flag_auto_profile
= true;
2368 /* No break here - do -fauto-profile processing. */
2370 case OPT_fauto_profile
:
2371 enable_fdo_optimizations (opts
, opts_set
, value
);
2372 if (!opts_set
->x_flag_profile_correction
)
2373 opts
->x_flag_profile_correction
= value
;
2374 maybe_set_param_value (
2375 PARAM_EARLY_INLINER_MAX_ITERATIONS
, 10,
2376 opts
->x_param_values
, opts_set
->x_param_values
);
2379 case OPT_fprofile_generate_
:
2380 opts
->x_profile_data_prefix
= xstrdup (arg
);
2382 /* No break here - do -fprofile-generate processing. */
2384 case OPT_fprofile_generate
:
2385 if (!opts_set
->x_profile_arc_flag
)
2386 opts
->x_profile_arc_flag
= value
;
2387 if (!opts_set
->x_flag_profile_values
)
2388 opts
->x_flag_profile_values
= value
;
2389 if (!opts_set
->x_flag_inline_functions
)
2390 opts
->x_flag_inline_functions
= value
;
2391 if (!opts_set
->x_flag_ipa_bit_cp
)
2392 opts
->x_flag_ipa_bit_cp
= value
;
2393 /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
2394 quadratic. Disable the pass until better memory representation
2396 if (!opts_set
->x_flag_ipa_reference
)
2397 opts
->x_flag_ipa_reference
= false;
2400 case OPT_fpatchable_function_entry_
:
2402 char *patch_area_arg
= xstrdup (arg
);
2403 char *comma
= strchr (patch_area_arg
, ',');
2407 function_entry_patch_area_size
=
2408 integral_argument (patch_area_arg
);
2409 function_entry_patch_area_start
=
2410 integral_argument (comma
+ 1);
2414 function_entry_patch_area_size
=
2415 integral_argument (patch_area_arg
);
2416 function_entry_patch_area_start
= 0;
2418 if (function_entry_patch_area_size
< 0
2419 || function_entry_patch_area_start
< 0
2420 || function_entry_patch_area_size
2421 < function_entry_patch_area_start
)
2422 error ("invalid arguments for %<-fpatchable_function_entry%>");
2423 free (patch_area_arg
);
2427 case OPT_ftree_vectorize
:
2428 /* Automatically sets -ftree-loop-vectorize and
2429 -ftree-slp-vectorize. Nothing more to do here. */
2431 case OPT_fshow_column
:
2432 dc
->show_column
= value
;
2435 case OPT_frandom_seed
:
2436 /* The real switch is -fno-random-seed. */
2442 case OPT_frandom_seed_
:
2446 case OPT_fsched_verbose_
:
2447 #ifdef INSN_SCHEDULING
2448 /* Handled with Var in common.opt. */
2454 case OPT_fsched_stalled_insns_
:
2455 opts
->x_flag_sched_stalled_insns
= value
;
2456 if (opts
->x_flag_sched_stalled_insns
== 0)
2457 opts
->x_flag_sched_stalled_insns
= -1;
2460 case OPT_fsched_stalled_insns_dep_
:
2461 opts
->x_flag_sched_stalled_insns_dep
= value
;
2464 case OPT_fstack_check_
:
2465 if (!strcmp (arg
, "no"))
2466 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
2467 else if (!strcmp (arg
, "generic"))
2468 /* This is the old stack checking method. */
2469 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2470 ? FULL_BUILTIN_STACK_CHECK
2471 : GENERIC_STACK_CHECK
;
2472 else if (!strcmp (arg
, "specific"))
2473 /* This is the new stack checking method. */
2474 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2475 ? FULL_BUILTIN_STACK_CHECK
2476 : STACK_CHECK_STATIC_BUILTIN
2477 ? STATIC_BUILTIN_STACK_CHECK
2478 : GENERIC_STACK_CHECK
;
2480 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
2483 case OPT_fstack_limit
:
2484 /* The real switch is -fno-stack-limit. */
2490 case OPT_fstack_limit_register_
:
2491 case OPT_fstack_limit_symbol_
:
2495 case OPT_fstack_usage
:
2496 opts
->x_flag_stack_usage
= value
;
2497 opts
->x_flag_stack_usage_info
= value
!= 0;
2501 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
2506 if (arg
&& strlen (arg
) != 0)
2508 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
2509 "use %<-gdwarf-%s%> for DWARF version "
2510 "or %<-gdwarf -g%s%> for debug level", arg
, arg
, arg
);
2514 value
= opts
->x_dwarf_version
;
2518 if (value
< 2 || value
> 5)
2519 error_at (loc
, "dwarf version %wu is not supported", value
);
2521 opts
->x_dwarf_version
= value
;
2522 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
2525 case OPT_gsplit_dwarf
:
2526 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, "", opts
, opts_set
,
2531 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
2536 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
, opts
, opts_set
,
2541 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2546 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
, opts
, opts_set
,
2552 /* Handled completely via specs. */
2555 case OPT_pedantic_errors
:
2556 dc
->pedantic_errors
= 1;
2557 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
2559 handlers
, opts
, opts_set
,
2564 opts
->x_flag_lto
= value
? "" : NULL
;
2568 dc
->dc_inhibit_warnings
= true;
2571 case OPT_fmax_errors_
:
2572 dc
->max_errors
= value
;
2575 case OPT_fuse_ld_bfd
:
2576 case OPT_fuse_ld_gold
:
2577 case OPT_fuse_ld_lld
:
2578 case OPT_fuse_linker_plugin
:
2579 /* No-op. Used by the driver and passed to us because it starts with f.*/
2584 opts
->x_flag_trapv
= 0;
2589 opts
->x_flag_wrapv
= 0;
2592 case OPT_fstrict_overflow
:
2593 opts
->x_flag_wrapv
= !value
;
2594 opts
->x_flag_wrapv_pointer
= !value
;
2596 opts
->x_flag_trapv
= 0;
2600 opts
->x_flag_ipa_icf_functions
= value
;
2601 opts
->x_flag_ipa_icf_variables
= value
;
2604 case OPT_falign_loops_
:
2605 check_alignment_argument (loc
, arg
, "loops");
2608 case OPT_falign_jumps_
:
2609 check_alignment_argument (loc
, arg
, "jumps");
2612 case OPT_falign_labels_
:
2613 check_alignment_argument (loc
, arg
, "labels");
2616 case OPT_falign_functions_
:
2617 check_alignment_argument (loc
, arg
, "functions");
2621 /* If the flag was handled in a standard way, assume the lack of
2622 processing here is intentional. */
2623 gcc_assert (option_flag_var (scode
, opts
));
2627 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
2632 /* Handle --param NAME=VALUE. */
2634 handle_param (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2635 location_t loc
, const char *carg
)
2640 arg
= xstrdup (carg
);
2641 equal
= strchr (arg
, '=');
2643 error_at (loc
, "%s: --param arguments should be of the form NAME=VALUE",
2649 enum compiler_param index
;
2650 if (!find_param (arg
, &index
))
2652 const char *suggestion
= find_param_fuzzy (arg
);
2654 error_at (loc
, "invalid --param name %qs; did you mean %qs?",
2657 error_at (loc
, "invalid --param name %qs", arg
);
2661 if (!param_string_value_p (index
, equal
+ 1, &value
))
2662 value
= integral_argument (equal
+ 1);
2665 error_at (loc
, "invalid --param value %qs", equal
+ 1);
2667 set_param_value (arg
, value
,
2668 opts
->x_param_values
, opts_set
->x_param_values
);
2675 /* Used to set the level of strict aliasing warnings in OPTS,
2676 when no level is specified (i.e., when -Wstrict-aliasing, and not
2677 -Wstrict-aliasing=level was given).
2678 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2679 and 0 otherwise. After calling this function, wstrict_aliasing will be
2680 set to the default value of -Wstrict_aliasing=level, currently 3. */
2682 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
2684 gcc_assert (onoff
== 0 || onoff
== 1);
2686 opts
->x_warn_strict_aliasing
= 3;
2688 opts
->x_warn_strict_aliasing
= 0;
2691 /* The following routines are useful in setting all the flags that
2692 -ffast-math and -fno-fast-math imply. */
2694 set_fast_math_flags (struct gcc_options
*opts
, int set
)
2696 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
2698 opts
->x_flag_unsafe_math_optimizations
= set
;
2699 set_unsafe_math_optimizations_flags (opts
, set
);
2701 if (!opts
->frontend_set_flag_finite_math_only
)
2702 opts
->x_flag_finite_math_only
= set
;
2703 if (!opts
->frontend_set_flag_errno_math
)
2704 opts
->x_flag_errno_math
= !set
;
2707 if (opts
->frontend_set_flag_excess_precision_cmdline
2708 == EXCESS_PRECISION_DEFAULT
)
2709 opts
->x_flag_excess_precision_cmdline
2710 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
2711 if (!opts
->frontend_set_flag_signaling_nans
)
2712 opts
->x_flag_signaling_nans
= 0;
2713 if (!opts
->frontend_set_flag_rounding_math
)
2714 opts
->x_flag_rounding_math
= 0;
2715 if (!opts
->frontend_set_flag_cx_limited_range
)
2716 opts
->x_flag_cx_limited_range
= 1;
2720 /* When -funsafe-math-optimizations is set the following
2721 flags are set as well. */
2723 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
2725 if (!opts
->frontend_set_flag_trapping_math
)
2726 opts
->x_flag_trapping_math
= !set
;
2727 if (!opts
->frontend_set_flag_signed_zeros
)
2728 opts
->x_flag_signed_zeros
= !set
;
2729 if (!opts
->frontend_set_flag_associative_math
)
2730 opts
->x_flag_associative_math
= set
;
2731 if (!opts
->frontend_set_flag_reciprocal_math
)
2732 opts
->x_flag_reciprocal_math
= set
;
2735 /* Return true iff flags in OPTS are set as if -ffast-math. */
2737 fast_math_flags_set_p (const struct gcc_options
*opts
)
2739 return (!opts
->x_flag_trapping_math
2740 && opts
->x_flag_unsafe_math_optimizations
2741 && opts
->x_flag_finite_math_only
2742 && !opts
->x_flag_signed_zeros
2743 && !opts
->x_flag_errno_math
2744 && opts
->x_flag_excess_precision_cmdline
2745 == EXCESS_PRECISION_FAST
);
2748 /* Return true iff flags are set as if -ffast-math but using the flags stored
2749 in the struct cl_optimization structure. */
2751 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
2753 return (!opt
->x_flag_trapping_math
2754 && opt
->x_flag_unsafe_math_optimizations
2755 && opt
->x_flag_finite_math_only
2756 && !opt
->x_flag_signed_zeros
2757 && !opt
->x_flag_errno_math
);
2760 /* Handle a debug output -g switch for options OPTS
2761 (OPTS_SET->x_write_symbols storing whether a debug type was passed
2762 explicitly), location LOC. EXTENDED is true or false to support
2763 extended output (2 is special and means "-ggdb" was given). */
2765 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
,
2766 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2769 opts
->x_use_gnu_debug_info_extensions
= extended
;
2771 if (type
== NO_DEBUG
)
2773 if (opts
->x_write_symbols
== NO_DEBUG
)
2775 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
2779 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
2780 opts
->x_write_symbols
= DWARF2_DEBUG
;
2781 #elif defined DBX_DEBUGGING_INFO
2782 opts
->x_write_symbols
= DBX_DEBUG
;
2786 if (opts
->x_write_symbols
== NO_DEBUG
)
2787 warning_at (loc
, 0, "target system does not support debug output");
2792 /* Does it conflict with an already selected type? */
2793 if (opts_set
->x_write_symbols
!= NO_DEBUG
2794 && opts
->x_write_symbols
!= NO_DEBUG
2795 && type
!= opts
->x_write_symbols
)
2796 error_at (loc
, "debug format %qs conflicts with prior selection",
2797 debug_type_names
[type
]);
2798 opts
->x_write_symbols
= type
;
2799 opts_set
->x_write_symbols
= type
;
2802 /* A debug flag without a level defaults to level 2.
2803 If off or at level 1, set it to level 2, but if already
2804 at level 3, don't lower it. */
2807 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
2808 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
2812 int argval
= integral_argument (arg
);
2814 error_at (loc
, "unrecognized debug output level %qs", arg
);
2815 else if (argval
> 3)
2816 error_at (loc
, "debug output level %qs is too high", arg
);
2818 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
2822 /* Arrange to dump core on error for diagnostic context DC. (The
2823 regular error message is still printed first, except in the case of
2827 setup_core_dumping (diagnostic_context
*dc
)
2830 signal (SIGABRT
, SIG_DFL
);
2832 #if defined(HAVE_SETRLIMIT)
2835 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
2836 fatal_error (input_location
, "getting core file size maximum limit: %m");
2837 rlim
.rlim_cur
= rlim
.rlim_max
;
2838 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
2839 fatal_error (input_location
,
2840 "setting core file size limit to maximum: %m");
2843 diagnostic_abort_on_error (dc
);
2846 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
2847 diagnostic context DC. */
2850 decode_d_option (const char *arg
, struct gcc_options
*opts
,
2851 location_t loc
, diagnostic_context
*dc
)
2859 opts
->x_flag_debug_asm
= 1;
2862 opts
->x_flag_print_asm_name
= 1;
2865 opts
->x_flag_dump_rtl_in_asm
= 1;
2866 opts
->x_flag_print_asm_name
= 1;
2869 opts
->x_rtl_dump_and_exit
= 1;
2871 case 'D': /* These are handled by the preprocessor. */
2878 setup_core_dumping (dc
);
2881 opts
->x_flag_dump_all_passed
= true;
2885 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
2890 /* Enable (or disable if VALUE is 0) a warning option ARG (language
2891 mask LANG_MASK, option handlers HANDLERS) as an error for option
2892 structures OPTS and OPTS_SET, diagnostic context DC (possibly
2893 NULL), location LOC. This is used by -Werror=. */
2896 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
2897 const struct cl_option_handlers
*handlers
,
2898 struct gcc_options
*opts
,
2899 struct gcc_options
*opts_set
,
2900 location_t loc
, diagnostic_context
*dc
)
2905 new_option
= XNEWVEC (char, strlen (arg
) + 2);
2906 new_option
[0] = 'W';
2907 strcpy (new_option
+ 1, arg
);
2908 option_index
= find_opt (new_option
, lang_mask
);
2909 if (option_index
== OPT_SPECIAL_unknown
)
2910 error_at (loc
, "-Werror=%s: no option -%s", arg
, new_option
);
2911 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
2912 error_at (loc
, "-Werror=%s: -%s is not an option that controls warnings",
2916 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
2917 const char *arg
= NULL
;
2919 if (cl_options
[option_index
].flags
& CL_JOINED
)
2920 arg
= new_option
+ cl_options
[option_index
].opt_len
;
2921 control_warning_option (option_index
, (int) kind
, arg
, value
,
2923 handlers
, opts
, opts_set
, dc
);
2928 /* Return malloced memory for the name of the option OPTION_INDEX
2929 which enabled a diagnostic (context CONTEXT), originally of type
2930 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2934 option_name (diagnostic_context
*context
, int option_index
,
2935 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
2939 /* A warning classified as an error. */
2940 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
2941 && diag_kind
== DK_ERROR
)
2942 return concat (cl_options
[OPT_Werror_
].opt_text
,
2943 /* Skip over "-W". */
2944 cl_options
[option_index
].opt_text
+ 2,
2946 /* A warning with option. */
2948 return xstrdup (cl_options
[option_index
].opt_text
);
2950 /* A warning without option classified as an error. */
2951 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
2952 || diag_kind
== DK_WARNING
)
2953 && context
->warning_as_error_requested
)
2954 return xstrdup (cl_options
[OPT_Werror
].opt_text
);