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. */
440 static const struct default_options default_options_table
[] =
442 /* -O1 optimizations. */
443 { OPT_LEVELS_1_PLUS
, OPT_fdefer_pop
, NULL
, 1 },
445 { OPT_LEVELS_1_PLUS
, OPT_fdelayed_branch
, NULL
, 1 },
447 { OPT_LEVELS_1_PLUS
, OPT_fguess_branch_probability
, NULL
, 1 },
448 { OPT_LEVELS_1_PLUS
, OPT_fcprop_registers
, NULL
, 1 },
449 { OPT_LEVELS_1_PLUS
, OPT_fforward_propagate
, NULL
, 1 },
450 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion
, NULL
, 1 },
451 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion2
, NULL
, 1 },
452 { OPT_LEVELS_1_PLUS
, OPT_fipa_pure_const
, NULL
, 1 },
453 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference
, NULL
, 1 },
454 { OPT_LEVELS_1_PLUS
, OPT_fipa_profile
, NULL
, 1 },
455 { OPT_LEVELS_1_PLUS
, OPT_fmerge_constants
, NULL
, 1 },
456 { OPT_LEVELS_1_PLUS
, OPT_freorder_blocks
, NULL
, 1 },
457 { OPT_LEVELS_1_PLUS
, OPT_fshrink_wrap
, NULL
, 1 },
458 { OPT_LEVELS_1_PLUS
, OPT_fsplit_wide_types
, NULL
, 1 },
459 { OPT_LEVELS_1_PLUS
, OPT_ftree_ccp
, NULL
, 1 },
460 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_bit_ccp
, NULL
, 1 },
461 { OPT_LEVELS_1_PLUS
, OPT_ftree_coalesce_vars
, NULL
, 1 },
462 { OPT_LEVELS_1_PLUS
, OPT_ftree_dce
, NULL
, 1 },
463 { OPT_LEVELS_1_PLUS
, OPT_ftree_dominator_opts
, NULL
, 1 },
464 { OPT_LEVELS_1_PLUS
, OPT_ftree_dse
, NULL
, 1 },
465 { OPT_LEVELS_1_PLUS
, OPT_ftree_ter
, NULL
, 1 },
466 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_sra
, NULL
, 1 },
467 { OPT_LEVELS_1_PLUS
, OPT_ftree_fre
, NULL
, 1 },
468 { OPT_LEVELS_1_PLUS
, OPT_ftree_copy_prop
, NULL
, 1 },
469 { OPT_LEVELS_1_PLUS
, OPT_ftree_sink
, NULL
, 1 },
470 { OPT_LEVELS_1_PLUS
, OPT_ftree_ch
, NULL
, 1 },
471 { OPT_LEVELS_1_PLUS
, OPT_fcombine_stack_adjustments
, NULL
, 1 },
472 { OPT_LEVELS_1_PLUS
, OPT_fcompare_elim
, NULL
, 1 },
473 { OPT_LEVELS_1_PLUS
, OPT_ftree_slsr
, NULL
, 1 },
474 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fbranch_count_reg
, NULL
, 1 },
475 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_invariants
, NULL
, 1 },
476 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_pta
, NULL
, 1 },
477 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fssa_phiopt
, NULL
, 1 },
478 { OPT_LEVELS_1_PLUS
, OPT_ftree_builtin_call_dce
, NULL
, 1 },
479 { OPT_LEVELS_1_PLUS
, OPT_fomit_frame_pointer
, NULL
, 1 },
481 /* -O2 optimizations. */
482 { OPT_LEVELS_2_PLUS
, OPT_finline_small_functions
, NULL
, 1 },
483 { OPT_LEVELS_2_PLUS
, OPT_findirect_inlining
, NULL
, 1 },
484 { OPT_LEVELS_2_PLUS
, OPT_fpartial_inlining
, NULL
, 1 },
485 { OPT_LEVELS_2_PLUS
, OPT_fthread_jumps
, NULL
, 1 },
486 { OPT_LEVELS_2_PLUS
, OPT_fcrossjumping
, NULL
, 1 },
487 { OPT_LEVELS_2_PLUS
, OPT_foptimize_sibling_calls
, NULL
, 1 },
488 { OPT_LEVELS_2_PLUS
, OPT_fcse_follow_jumps
, NULL
, 1 },
489 { OPT_LEVELS_2_PLUS
, OPT_fgcse
, NULL
, 1 },
490 { OPT_LEVELS_2_PLUS
, OPT_fexpensive_optimizations
, NULL
, 1 },
491 { OPT_LEVELS_2_PLUS
, OPT_frerun_cse_after_loop
, NULL
, 1 },
492 { OPT_LEVELS_2_PLUS
, OPT_fcaller_saves
, NULL
, 1 },
493 { OPT_LEVELS_2_PLUS
, OPT_fpeephole2
, NULL
, 1 },
494 #ifdef INSN_SCHEDULING
495 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
496 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_fschedule_insns
, NULL
, 1 },
497 { OPT_LEVELS_2_PLUS
, OPT_fschedule_insns2
, NULL
, 1 },
499 { OPT_LEVELS_2_PLUS
, OPT_fstrict_aliasing
, NULL
, 1 },
500 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_freorder_blocks_algorithm_
, NULL
,
501 REORDER_BLOCKS_ALGORITHM_STC
},
502 { OPT_LEVELS_2_PLUS
, OPT_freorder_functions
, NULL
, 1 },
503 { OPT_LEVELS_2_PLUS
, OPT_ftree_vrp
, NULL
, 1 },
504 { OPT_LEVELS_2_PLUS
, OPT_fcode_hoisting
, NULL
, 1 },
505 { OPT_LEVELS_2_PLUS
, OPT_ftree_pre
, NULL
, 1 },
506 { OPT_LEVELS_2_PLUS
, OPT_ftree_switch_conversion
, NULL
, 1 },
507 { OPT_LEVELS_2_PLUS
, OPT_fipa_cp
, NULL
, 1 },
508 { OPT_LEVELS_2_PLUS
, OPT_fipa_bit_cp
, NULL
, 1 },
509 { OPT_LEVELS_2_PLUS
, OPT_fipa_vrp
, NULL
, 1 },
510 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize
, NULL
, 1 },
511 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize_speculatively
, NULL
, 1 },
512 { OPT_LEVELS_2_PLUS
, OPT_fipa_sra
, NULL
, 1 },
513 { OPT_LEVELS_2_PLUS
, OPT_falign_loops
, NULL
, 1 },
514 { OPT_LEVELS_2_PLUS
, OPT_falign_jumps
, NULL
, 1 },
515 { OPT_LEVELS_2_PLUS
, OPT_falign_labels
, NULL
, 1 },
516 { OPT_LEVELS_2_PLUS
, OPT_falign_functions
, NULL
, 1 },
517 { OPT_LEVELS_2_PLUS
, OPT_ftree_tail_merge
, NULL
, 1 },
518 { OPT_LEVELS_2_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_CHEAP
},
519 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_foptimize_strlen
, NULL
, 1 },
520 { OPT_LEVELS_2_PLUS
, OPT_fhoist_adjacent_loads
, NULL
, 1 },
521 { OPT_LEVELS_2_PLUS
, OPT_fipa_icf
, NULL
, 1 },
522 { OPT_LEVELS_2_PLUS
, OPT_fisolate_erroneous_paths_dereference
, NULL
, 1 },
523 { OPT_LEVELS_2_PLUS
, OPT_fipa_ra
, NULL
, 1 },
524 { OPT_LEVELS_2_PLUS
, OPT_flra_remat
, NULL
, 1 },
525 { OPT_LEVELS_2_PLUS
, OPT_fstore_merging
, NULL
, 1 },
527 /* -O3 optimizations. */
528 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribute_patterns
, NULL
, 1 },
529 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribution
, NULL
, 1 },
530 { OPT_LEVELS_3_PLUS
, OPT_floop_interchange
, NULL
, 1 },
531 { OPT_LEVELS_3_PLUS
, OPT_fpredictive_commoning
, NULL
, 1 },
532 { OPT_LEVELS_3_PLUS
, OPT_fsplit_paths
, NULL
, 1 },
533 /* Inlining of functions reducing size is a good idea with -Os
534 regardless of them being declared inline. */
535 { OPT_LEVELS_3_PLUS_AND_SIZE
, OPT_finline_functions
, NULL
, 1 },
536 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_finline_functions_called_once
, NULL
, 1 },
537 { OPT_LEVELS_3_PLUS
, OPT_fsplit_loops
, NULL
, 1 },
538 { OPT_LEVELS_3_PLUS
, OPT_funswitch_loops
, NULL
, 1 },
539 { OPT_LEVELS_3_PLUS
, OPT_floop_unroll_and_jam
, NULL
, 1 },
540 { OPT_LEVELS_3_PLUS
, OPT_fgcse_after_reload
, NULL
, 1 },
541 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_vectorize
, NULL
, 1 },
542 { OPT_LEVELS_3_PLUS
, OPT_ftree_slp_vectorize
, NULL
, 1 },
543 { OPT_LEVELS_3_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_DYNAMIC
},
544 { OPT_LEVELS_3_PLUS
, OPT_fipa_cp_clone
, NULL
, 1 },
545 { OPT_LEVELS_3_PLUS
, OPT_ftree_partial_pre
, NULL
, 1 },
546 { OPT_LEVELS_3_PLUS
, OPT_fpeel_loops
, NULL
, 1 },
548 /* -Ofast adds optimizations to -O3. */
549 { OPT_LEVELS_FAST
, OPT_ffast_math
, NULL
, 1 },
551 { OPT_LEVELS_NONE
, 0, NULL
, 0 }
554 /* Default the options in OPTS and OPTS_SET based on the optimization
555 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
557 default_options_optimization (struct gcc_options
*opts
,
558 struct gcc_options
*opts_set
,
559 struct cl_decoded_option
*decoded_options
,
560 unsigned int decoded_options_count
,
562 unsigned int lang_mask
,
563 const struct cl_option_handlers
*handlers
,
564 diagnostic_context
*dc
)
568 bool openacc_mode
= false;
570 /* Scan to see what optimization level has been specified. That will
571 determine the default value of many flags. */
572 for (i
= 1; i
< decoded_options_count
; i
++)
574 struct cl_decoded_option
*opt
= &decoded_options
[i
];
575 switch (opt
->opt_index
)
578 if (*opt
->arg
== '\0')
580 opts
->x_optimize
= 1;
581 opts
->x_optimize_size
= 0;
582 opts
->x_optimize_fast
= 0;
583 opts
->x_optimize_debug
= 0;
587 const int optimize_val
= integral_argument (opt
->arg
);
588 if (optimize_val
== -1)
589 error_at (loc
, "argument to %<-O%> should be a non-negative "
590 "integer, %<g%>, %<s%> or %<fast%>");
593 opts
->x_optimize
= optimize_val
;
594 if ((unsigned int) opts
->x_optimize
> 255)
595 opts
->x_optimize
= 255;
596 opts
->x_optimize_size
= 0;
597 opts
->x_optimize_fast
= 0;
598 opts
->x_optimize_debug
= 0;
604 opts
->x_optimize_size
= 1;
606 /* Optimizing for size forces optimize to be 2. */
607 opts
->x_optimize
= 2;
608 opts
->x_optimize_fast
= 0;
609 opts
->x_optimize_debug
= 0;
613 /* -Ofast only adds flags to -O3. */
614 opts
->x_optimize_size
= 0;
615 opts
->x_optimize
= 3;
616 opts
->x_optimize_fast
= 1;
617 opts
->x_optimize_debug
= 0;
621 /* -Og selects optimization level 1. */
622 opts
->x_optimize_size
= 0;
623 opts
->x_optimize
= 1;
624 opts
->x_optimize_fast
= 0;
625 opts
->x_optimize_debug
= 1;
634 /* Ignore other options in this prescan. */
639 maybe_default_options (opts
, opts_set
, default_options_table
,
640 opts
->x_optimize
, opts
->x_optimize_size
,
641 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
642 lang_mask
, handlers
, loc
, dc
);
644 /* -O2 param settings. */
645 opt2
= (opts
->x_optimize
>= 2);
648 && !opts_set
->x_flag_ipa_pta
)
649 opts
->x_flag_ipa_pta
= true;
651 /* Track fields in field-sensitive alias analysis. */
652 maybe_set_param_value
653 (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
,
654 opt2
? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
),
655 opts
->x_param_values
, opts_set
->x_param_values
);
657 /* For -O1 only do loop invariant motion for very small loops. */
658 maybe_set_param_value
659 (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
,
660 opt2
? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
) : 1000,
661 opts
->x_param_values
, opts_set
->x_param_values
);
663 /* At -Ofast, allow store motion to introduce potential race conditions. */
664 maybe_set_param_value
665 (PARAM_ALLOW_STORE_DATA_RACES
,
666 opts
->x_optimize_fast
? 1
667 : default_param_value (PARAM_ALLOW_STORE_DATA_RACES
),
668 opts
->x_param_values
, opts_set
->x_param_values
);
670 if (opts
->x_optimize_size
)
671 /* We want to crossjump as much as possible. */
672 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
, 1,
673 opts
->x_param_values
, opts_set
->x_param_values
);
675 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
,
676 default_param_value (PARAM_MIN_CROSSJUMP_INSNS
),
677 opts
->x_param_values
, opts_set
->x_param_values
);
679 /* Restrict the amount of work combine does at -Og while retaining
680 most of its useful transforms. */
681 if (opts
->x_optimize_debug
)
682 maybe_set_param_value (PARAM_MAX_COMBINE_INSNS
, 2,
683 opts
->x_param_values
, opts_set
->x_param_values
);
685 /* Allow default optimizations to be specified on a per-machine basis. */
686 maybe_default_options (opts
, opts_set
,
687 targetm_common
.option_optimization_table
,
688 opts
->x_optimize
, opts
->x_optimize_size
,
689 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
690 lang_mask
, handlers
, loc
, dc
);
693 /* After all options at LOC have been read into OPTS and OPTS_SET,
694 finalize settings of those options and diagnose incompatible
697 finish_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
700 enum unwind_info_type ui_except
;
702 if (opts
->x_dump_base_name
703 && ! opts
->x_dump_base_name_prefixed
)
705 const char *sep
= opts
->x_dump_base_name
;
708 if (IS_DIR_SEPARATOR (*sep
))
712 /* If dump_base_path contains subdirectories, don't prepend
714 else if (opts
->x_dump_dir_name
)
715 /* We have a DUMP_DIR_NAME, prepend that. */
716 opts
->x_dump_base_name
= opts_concat (opts
->x_dump_dir_name
,
717 opts
->x_dump_base_name
, NULL
);
718 else if (opts
->x_aux_base_name
719 && strcmp (opts
->x_aux_base_name
, HOST_BIT_BUCKET
) != 0)
720 /* AUX_BASE_NAME is set and is not the bit bucket. If it
721 contains a directory component, prepend those directories.
722 Typically this places things in the same directory as the
725 const char *aux_base
;
727 base_of_path (opts
->x_aux_base_name
, &aux_base
);
728 if (opts
->x_aux_base_name
!= aux_base
)
730 int dir_len
= aux_base
- opts
->x_aux_base_name
;
731 char *new_dump_base_name
732 = XOBNEWVEC (&opts_obstack
, char,
733 strlen (opts
->x_dump_base_name
) + dir_len
+ 1);
735 /* Copy directory component from OPTS->X_AUX_BASE_NAME. */
736 memcpy (new_dump_base_name
, opts
->x_aux_base_name
, dir_len
);
737 /* Append existing OPTS->X_DUMP_BASE_NAME. */
738 strcpy (new_dump_base_name
+ dir_len
, opts
->x_dump_base_name
);
739 opts
->x_dump_base_name
= new_dump_base_name
;
743 /* It is definitely prefixed now. */
744 opts
->x_dump_base_name_prefixed
= true;
747 /* Handle related options for unit-at-a-time, toplevel-reorder, and
749 if (!opts
->x_flag_unit_at_a_time
)
751 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
752 error_at (loc
, "section anchors must be disabled when unit-at-a-time "
754 opts
->x_flag_section_anchors
= 0;
755 if (opts
->x_flag_toplevel_reorder
== 1)
756 error_at (loc
, "toplevel reorder must be disabled when unit-at-a-time "
758 opts
->x_flag_toplevel_reorder
= 0;
761 /* -fself-test depends on the state of the compiler prior to
762 compiling anything. Ideally it should be run on an empty source
763 file. However, in case we get run with actual source, assume
764 -fsyntax-only which will inhibit any compiler initialization
765 which may confuse the self tests. */
766 if (opts
->x_flag_self_test
)
767 opts
->x_flag_syntax_only
= 1;
769 if (opts
->x_flag_tm
&& opts
->x_flag_non_call_exceptions
)
770 sorry ("transactional memory is not supported with non-call exceptions");
772 /* Unless the user has asked for section anchors, we disable toplevel
773 reordering at -O0 to disable transformations that might be surprising
774 to end users and to get -fno-toplevel-reorder tested. */
775 if (!opts
->x_optimize
776 && opts
->x_flag_toplevel_reorder
== 2
777 && !(opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
))
779 opts
->x_flag_toplevel_reorder
= 0;
780 opts
->x_flag_section_anchors
= 0;
782 if (!opts
->x_flag_toplevel_reorder
)
784 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
785 error_at (loc
, "section anchors must be disabled when toplevel reorder"
787 opts
->x_flag_section_anchors
= 0;
790 if (!opts
->x_flag_opts_finished
)
792 /* We initialize opts->x_flag_pie to -1 so that targets can set a
794 if (opts
->x_flag_pie
== -1)
796 /* We initialize opts->x_flag_pic to -1 so that we can tell if
797 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
798 if (opts
->x_flag_pic
== -1)
799 opts
->x_flag_pie
= DEFAULT_FLAG_PIE
;
801 opts
->x_flag_pie
= 0;
803 /* If -fPIE or -fpie is used, turn on PIC. */
804 if (opts
->x_flag_pie
)
805 opts
->x_flag_pic
= opts
->x_flag_pie
;
806 else if (opts
->x_flag_pic
== -1)
807 opts
->x_flag_pic
= 0;
808 if (opts
->x_flag_pic
&& !opts
->x_flag_pie
)
809 opts
->x_flag_shlib
= 1;
810 opts
->x_flag_opts_finished
= true;
813 /* We initialize opts->x_flag_stack_protect to -1 so that targets
814 can set a default value. */
815 if (opts
->x_flag_stack_protect
== -1)
816 opts
->x_flag_stack_protect
= DEFAULT_FLAG_SSP
;
818 if (opts
->x_optimize
== 0)
820 /* Inlining does not work if not optimizing,
821 so force it not to be done. */
822 opts
->x_warn_inline
= 0;
823 opts
->x_flag_no_inline
= 1;
826 /* The optimization to partition hot and cold basic blocks into separate
827 sections of the .o and executable files does not work (currently)
828 with exception handling. This is because there is no support for
829 generating unwind info. If opts->x_flag_exceptions is turned on
830 we need to turn off the partitioning optimization. */
832 ui_except
= targetm_common
.except_unwind_info (opts
);
834 if (opts
->x_flag_exceptions
835 && opts
->x_flag_reorder_blocks_and_partition
836 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
838 if (opts_set
->x_flag_reorder_blocks_and_partition
)
840 "%<-freorder-blocks-and-partition%> does not work "
841 "with exceptions on this architecture");
842 opts
->x_flag_reorder_blocks_and_partition
= 0;
843 opts
->x_flag_reorder_blocks
= 1;
846 /* If user requested unwind info, then turn off the partitioning
849 if (opts
->x_flag_unwind_tables
850 && !targetm_common
.unwind_tables_default
851 && opts
->x_flag_reorder_blocks_and_partition
852 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
854 if (opts_set
->x_flag_reorder_blocks_and_partition
)
856 "%<-freorder-blocks-and-partition%> does not support "
857 "unwind info on this architecture");
858 opts
->x_flag_reorder_blocks_and_partition
= 0;
859 opts
->x_flag_reorder_blocks
= 1;
862 /* If the target requested unwind info, then turn off the partitioning
863 optimization with a different message. Likewise, if the target does not
864 support named sections. */
866 if (opts
->x_flag_reorder_blocks_and_partition
867 && (!targetm_common
.have_named_sections
868 || (opts
->x_flag_unwind_tables
869 && targetm_common
.unwind_tables_default
870 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
872 if (opts_set
->x_flag_reorder_blocks_and_partition
)
874 "%<-freorder-blocks-and-partition%> does not work "
875 "on this architecture");
876 opts
->x_flag_reorder_blocks_and_partition
= 0;
877 opts
->x_flag_reorder_blocks
= 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 "
914 opts
->x_flag_fat_lto_objects
= 1;
918 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
919 default value if they choose based on other options. */
920 if (opts
->x_flag_split_stack
== -1)
921 opts
->x_flag_split_stack
= 0;
922 else if (opts
->x_flag_split_stack
)
924 if (!targetm_common
.supports_split_stack (true, opts
))
926 error_at (loc
, "%<-fsplit-stack%> is not supported by "
927 "this compiler configuration");
928 opts
->x_flag_split_stack
= 0;
932 /* If stack splitting is turned on, and the user did not explicitly
933 request function partitioning, turn off partitioning, as it
934 confuses the linker when trying to handle partitioned split-stack
935 code that calls a non-split-stack functions. But if partitioning
936 was turned on explicitly just hope for the best. */
937 if (opts
->x_flag_split_stack
938 && opts
->x_flag_reorder_blocks_and_partition
939 && !opts_set
->x_flag_reorder_blocks_and_partition
)
940 opts
->x_flag_reorder_blocks_and_partition
= 0;
942 if (opts
->x_flag_reorder_blocks_and_partition
943 && !opts_set
->x_flag_reorder_functions
)
944 opts
->x_flag_reorder_functions
= 1;
946 /* Tune vectorization related parametees according to cost model. */
947 if (opts
->x_flag_vect_cost_model
== VECT_COST_MODEL_CHEAP
)
949 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS
,
950 6, opts
->x_param_values
, opts_set
->x_param_values
);
951 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS
,
952 0, opts
->x_param_values
, opts_set
->x_param_values
);
953 maybe_set_param_value (PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT
,
954 0, opts
->x_param_values
, opts_set
->x_param_values
);
957 /* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
959 if ((!opts
->x_flag_tree_loop_vectorize
&& !opts
->x_flag_tree_slp_vectorize
)
960 || !opts
->x_flag_tree_loop_if_convert
)
961 maybe_set_param_value (PARAM_MAX_STORES_TO_SINK
, 0,
962 opts
->x_param_values
, opts_set
->x_param_values
);
964 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
965 if (opts
->x_dwarf_split_debug_info
)
966 opts
->x_debug_generate_pub_sections
= 2;
968 if ((opts
->x_flag_sanitize
969 & (SANITIZE_USER_ADDRESS
| SANITIZE_KERNEL_ADDRESS
)) == 0)
971 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_COMPARE
)
973 "%<-fsanitize=pointer-compare%> must be combined with "
974 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
975 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_SUBTRACT
)
977 "%<-fsanitize=pointer-subtract%> must be combined with "
978 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
981 /* Userspace and kernel ASan conflict with each other. */
982 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
983 && (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
))
985 "%<-fsanitize=address%> is incompatible with "
986 "%<-fsanitize=kernel-address%>");
989 if ((opts
->x_flag_sanitize
& SANITIZE_ADDRESS
)
990 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
992 "%<-fsanitize=address%> and %<-fsanitize=kernel-address%> "
993 "are incompatible with %<-fsanitize=thread%>");
995 if ((opts
->x_flag_sanitize
& SANITIZE_LEAK
)
996 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
998 "%<-fsanitize=leak%> is incompatible with %<-fsanitize=thread%>");
1000 /* Check error recovery for -fsanitize-recover option. */
1001 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1002 if ((opts
->x_flag_sanitize_recover
& sanitizer_opts
[i
].flag
)
1003 && !sanitizer_opts
[i
].can_recover
)
1004 error_at (loc
, "%<-fsanitize-recover=%s%> is not supported",
1005 sanitizer_opts
[i
].name
);
1007 /* When instrumenting the pointers, we don't want to remove
1008 the null pointer checks. */
1009 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
1010 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
1011 opts
->x_flag_delete_null_pointer_checks
= 0;
1013 /* Aggressive compiler optimizations may cause false negatives. */
1014 if (opts
->x_flag_sanitize
& ~(SANITIZE_LEAK
| SANITIZE_UNREACHABLE
))
1015 opts
->x_flag_aggressive_loop_optimizations
= 0;
1017 /* Enable -fsanitize-address-use-after-scope if address sanitizer is
1019 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
1020 && !opts_set
->x_flag_sanitize_address_use_after_scope
)
1021 opts
->x_flag_sanitize_address_use_after_scope
= true;
1023 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1025 if (opts
->x_flag_sanitize_address_use_after_scope
)
1027 if (opts
->x_flag_stack_reuse
!= SR_NONE
1028 && opts_set
->x_flag_stack_reuse
!= SR_NONE
)
1030 "%<-fsanitize-address-use-after-scope%> requires "
1031 "%<-fstack-reuse=none%> option");
1033 opts
->x_flag_stack_reuse
= SR_NONE
;
1036 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
) && opts
->x_flag_tm
)
1037 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1039 if ((opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) && opts
->x_flag_tm
)
1040 sorry ("transactional memory is not supported with "
1041 "%<-fsanitize=kernel-address%>");
1044 #define LEFT_COLUMN 27
1046 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1047 followed by word-wrapped HELP in a second column. */
1049 wrap_help (const char *help
,
1051 unsigned int item_width
,
1052 unsigned int columns
)
1054 unsigned int col_width
= LEFT_COLUMN
;
1055 unsigned int remaining
, room
, len
;
1057 remaining
= strlen (help
);
1061 room
= columns
- 3 - MAX (col_width
, item_width
);
1070 for (i
= 0; help
[i
]; i
++)
1072 if (i
>= room
&& len
!= remaining
)
1076 else if ((help
[i
] == '-' || help
[i
] == '/')
1077 && help
[i
+ 1] != ' '
1078 && i
> 0 && ISALPHA (help
[i
- 1]))
1083 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1085 while (help
[len
] == ' ')
1093 /* Print help for a specific front-end, etc. */
1095 print_filtered_help (unsigned int include_flags
,
1096 unsigned int exclude_flags
,
1097 unsigned int any_flags
,
1098 unsigned int columns
,
1099 struct gcc_options
*opts
,
1100 unsigned int lang_mask
)
1105 bool displayed
= false;
1108 if (include_flags
== CL_PARAMS
)
1110 for (i
= 0; i
< LAST_PARAM
; i
++)
1112 const char *param
= compiler_params
[i
].option
;
1114 help
= compiler_params
[i
].help
;
1115 if (help
== NULL
|| *help
== '\0')
1117 if (exclude_flags
& CL_UNDOCUMENTED
)
1119 help
= undocumented_msg
;
1122 /* Get the translation. */
1125 if (!opts
->x_quiet_flag
)
1127 snprintf (new_help
, sizeof (new_help
),
1128 _("default %d minimum %d maximum %d"),
1129 compiler_params
[i
].default_value
,
1130 compiler_params
[i
].min_value
,
1131 compiler_params
[i
].max_value
);
1134 wrap_help (help
, param
, strlen (param
), columns
);
1140 if (!opts
->x_help_printed
)
1141 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1143 if (!opts
->x_help_enum_printed
)
1144 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1146 for (i
= 0; i
< cl_options_count
; i
++)
1148 const struct cl_option
*option
= cl_options
+ i
;
1153 if (include_flags
== 0
1154 || ((option
->flags
& include_flags
) != include_flags
))
1156 if ((option
->flags
& any_flags
) == 0)
1160 /* Skip unwanted switches. */
1161 if ((option
->flags
& exclude_flags
) != 0)
1164 /* The driver currently prints its own help text. */
1165 if ((option
->flags
& CL_DRIVER
) != 0
1166 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1167 | CL_COMMON
| CL_TARGET
)) == 0)
1171 /* Skip switches that have already been printed. */
1172 if (opts
->x_help_printed
[i
])
1175 opts
->x_help_printed
[i
] = true;
1177 help
= option
->help
;
1180 if (exclude_flags
& CL_UNDOCUMENTED
)
1183 help
= undocumented_msg
;
1186 if (option
->alias_target
< N_OPTS
1187 && cl_options
[option
->alias_target
].help
)
1189 if (help
== undocumented_msg
)
1191 /* For undocumented options that are aliases for other options
1192 that are documented, point the reader to the other option in
1193 preference of the former. */
1194 snprintf (new_help
, sizeof new_help
,
1195 _("Same as %s. Use the latter option instead."),
1196 cl_options
[option
->alias_target
].opt_text
);
1200 /* For documented options with aliases, mention the aliased
1201 option's name for reference. */
1202 snprintf (new_help
, sizeof new_help
,
1203 _("%s Same as %s."),
1204 help
, cl_options
[option
->alias_target
].opt_text
);
1210 if (option
->warn_message
)
1212 /* Mention that the use of the option will trigger a warning. */
1213 if (help
== new_help
)
1214 snprintf (new_help
+ strlen (new_help
),
1215 sizeof new_help
- strlen (new_help
),
1216 " %s", _(use_diagnosed_msg
));
1218 snprintf (new_help
, sizeof new_help
,
1219 "%s %s", help
, _(use_diagnosed_msg
));
1224 /* Get the translation. */
1227 /* Find the gap between the name of the
1228 option and its descriptive text. */
1229 tab
= strchr (help
, '\t');
1238 opt
= option
->opt_text
;
1242 /* With the -Q option enabled we change the descriptive text associated
1243 with an option to be an indication of its current setting. */
1244 if (!opts
->x_quiet_flag
)
1246 void *flag_var
= option_flag_var (i
, opts
);
1248 if (len
< (LEFT_COLUMN
+ 2))
1249 strcpy (new_help
, "\t\t");
1251 strcpy (new_help
, "\t");
1253 if (flag_var
!= NULL
1254 && option
->var_type
!= CLVC_DEFER
)
1256 if (option
->flags
& CL_JOINED
)
1258 if (option
->var_type
== CLVC_STRING
)
1260 if (* (const char **) flag_var
!= NULL
)
1261 snprintf (new_help
+ strlen (new_help
),
1262 sizeof (new_help
) - strlen (new_help
),
1263 "%s", * (const char **) flag_var
);
1265 else if (option
->var_type
== CLVC_ENUM
)
1267 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1269 const char *arg
= NULL
;
1271 value
= e
->get (flag_var
);
1272 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1274 arg
= _("[default]");
1275 snprintf (new_help
+ strlen (new_help
),
1276 sizeof (new_help
) - strlen (new_help
),
1280 sprintf (new_help
+ strlen (new_help
),
1281 "%d", * (int *) flag_var
);
1284 strcat (new_help
, option_enabled (i
, opts
)
1285 ? _("[enabled]") : _("[disabled]"));
1291 if (option
->range_max
!= -1)
1294 snprintf (b
, sizeof (b
), "<%d,%d>", option
->range_min
,
1296 opt
= concat (opt
, b
, NULL
);
1300 wrap_help (help
, opt
, len
, columns
);
1303 if (option
->var_type
== CLVC_ENUM
1304 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1305 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1310 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1313 printf (_(" No options with the desired characteristics were found\n"));
1318 /* PR 31349: Tell the user how to see all of the
1319 options supported by a specific front end. */
1320 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1321 if ((1U << i
) & langs
)
1322 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1323 lang_names
[i
], lang_names
[i
]);
1327 else if (! displayed
)
1328 printf (_(" All options with the desired characteristics have already been displayed\n"));
1332 /* Print details of enumerated option arguments, if those
1333 enumerations have help text headings provided. If no help text
1334 is provided, presume that the possible values are listed in the
1335 help text for the relevant options. */
1336 for (i
= 0; i
< cl_enums_count
; i
++)
1338 unsigned int j
, pos
;
1340 if (opts
->x_help_enum_printed
[i
] != 1)
1342 if (cl_enums
[i
].help
== NULL
)
1344 printf (" %s\n ", _(cl_enums
[i
].help
));
1346 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1348 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1350 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1352 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1362 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1367 opts
->x_help_enum_printed
[i
] = 2;
1371 /* Display help for a specified type of option.
1372 The options must have ALL of the INCLUDE_FLAGS set
1373 ANY of the flags in the ANY_FLAGS set
1374 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1375 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1377 print_specific_help (unsigned int include_flags
,
1378 unsigned int exclude_flags
,
1379 unsigned int any_flags
,
1380 struct gcc_options
*opts
,
1381 unsigned int lang_mask
)
1383 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1384 const char * description
= NULL
;
1385 const char * descrip_extra
= "";
1389 /* Sanity check: Make sure that we do not have more
1390 languages than we have bits available to enumerate them. */
1391 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1393 /* If we have not done so already, obtain
1394 the desired maximum width of the output. */
1395 if (opts
->x_help_columns
== 0)
1397 opts
->x_help_columns
= get_terminal_width ();
1398 if (opts
->x_help_columns
== INT_MAX
)
1399 /* Use a reasonable default. */
1400 opts
->x_help_columns
= 80;
1403 /* Decide upon the title for the options that we are going to display. */
1404 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1406 switch (flag
& include_flags
)
1413 description
= _("The following options are target specific");
1416 description
= _("The following options control compiler warning messages");
1418 case CL_OPTIMIZATION
:
1419 description
= _("The following options control optimizations");
1422 description
= _("The following options are language-independent");
1425 description
= _("The --param option recognizes the following as parameters");
1428 if (i
>= cl_lang_count
)
1430 if (exclude_flags
& all_langs_mask
)
1431 description
= _("The following options are specific to just the language ");
1433 description
= _("The following options are supported by the language ");
1434 descrip_extra
= lang_names
[i
];
1439 if (description
== NULL
)
1443 if (include_flags
& CL_UNDOCUMENTED
)
1444 description
= _("The following options are not documented");
1445 else if (include_flags
& CL_SEPARATE
)
1446 description
= _("The following options take separate arguments");
1447 else if (include_flags
& CL_JOINED
)
1448 description
= _("The following options take joined arguments");
1451 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1458 if (any_flags
& all_langs_mask
)
1459 description
= _("The following options are language-related");
1461 description
= _("The following options are language-independent");
1465 printf ("%s%s:\n", description
, descrip_extra
);
1466 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
1467 opts
->x_help_columns
, opts
, lang_mask
);
1470 /* Enable FDO-related flags. */
1473 enable_fdo_optimizations (struct gcc_options
*opts
,
1474 struct gcc_options
*opts_set
,
1477 if (!opts_set
->x_flag_branch_probabilities
)
1478 opts
->x_flag_branch_probabilities
= value
;
1479 if (!opts_set
->x_flag_profile_values
)
1480 opts
->x_flag_profile_values
= value
;
1481 if (!opts_set
->x_flag_unroll_loops
)
1482 opts
->x_flag_unroll_loops
= value
;
1483 if (!opts_set
->x_flag_peel_loops
)
1484 opts
->x_flag_peel_loops
= value
;
1485 if (!opts_set
->x_flag_tracer
)
1486 opts
->x_flag_tracer
= value
;
1487 if (!opts_set
->x_flag_value_profile_transformations
)
1488 opts
->x_flag_value_profile_transformations
= value
;
1489 if (!opts_set
->x_flag_inline_functions
)
1490 opts
->x_flag_inline_functions
= value
;
1491 if (!opts_set
->x_flag_ipa_cp
)
1492 opts
->x_flag_ipa_cp
= value
;
1493 if (!opts_set
->x_flag_ipa_cp_clone
1494 && value
&& opts
->x_flag_ipa_cp
)
1495 opts
->x_flag_ipa_cp_clone
= value
;
1496 if (!opts_set
->x_flag_ipa_bit_cp
1497 && value
&& opts
->x_flag_ipa_cp
)
1498 opts
->x_flag_ipa_bit_cp
= value
;
1499 if (!opts_set
->x_flag_predictive_commoning
)
1500 opts
->x_flag_predictive_commoning
= value
;
1501 if (!opts_set
->x_flag_split_loops
)
1502 opts
->x_flag_split_loops
= value
;
1503 if (!opts_set
->x_flag_unswitch_loops
)
1504 opts
->x_flag_unswitch_loops
= value
;
1505 if (!opts_set
->x_flag_gcse_after_reload
)
1506 opts
->x_flag_gcse_after_reload
= value
;
1507 if (!opts_set
->x_flag_tree_loop_vectorize
)
1508 opts
->x_flag_tree_loop_vectorize
= value
;
1509 if (!opts_set
->x_flag_tree_slp_vectorize
)
1510 opts
->x_flag_tree_slp_vectorize
= value
;
1511 if (!opts_set
->x_flag_vect_cost_model
)
1512 opts
->x_flag_vect_cost_model
= VECT_COST_MODEL_DYNAMIC
;
1513 if (!opts_set
->x_flag_tree_loop_distribute_patterns
)
1514 opts
->x_flag_tree_loop_distribute_patterns
= value
;
1517 /* -f{,no-}sanitize{,-recover}= suboptions. */
1518 const struct sanitizer_opts_s sanitizer_opts
[] =
1520 #define SANITIZER_OPT(name, flags, recover) \
1521 { #name, flags, sizeof #name - 1, recover }
1522 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true),
1523 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
1525 SANITIZER_OPT (pointer
-compare
, SANITIZE_POINTER_COMPARE
, true),
1526 SANITIZER_OPT (pointer
-subtract
, SANITIZE_POINTER_SUBTRACT
, true),
1527 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false),
1528 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false),
1529 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true),
1530 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true),
1531 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true),
1532 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true),
1533 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true),
1534 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false),
1535 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true),
1536 SANITIZER_OPT (return, SANITIZE_RETURN
, false),
1537 SANITIZER_OPT (null
, SANITIZE_NULL
, true),
1538 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true),
1539 SANITIZER_OPT (bool, SANITIZE_BOOL
, true),
1540 SANITIZER_OPT (enum, SANITIZE_ENUM
, true),
1541 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true),
1542 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true),
1543 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true),
1544 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true),
1545 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true),
1546 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true),
1547 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
1549 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true),
1550 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true),
1551 SANITIZER_OPT (pointer
-overflow
, SANITIZE_POINTER_OVERFLOW
, true),
1552 SANITIZER_OPT (builtin
, SANITIZE_BUILTIN
, true),
1553 SANITIZER_OPT (all
, ~0U, true),
1554 #undef SANITIZER_OPT
1555 { NULL
, 0U, 0UL, false }
1558 /* -f{,no-}sanitize-coverage= suboptions. */
1559 const struct sanitizer_opts_s coverage_sanitizer_opts
[] =
1561 #define COVERAGE_SANITIZER_OPT(name, flags) \
1562 { #name, flags, sizeof #name - 1, true }
1563 COVERAGE_SANITIZER_OPT (trace
-pc
, SANITIZE_COV_TRACE_PC
),
1564 COVERAGE_SANITIZER_OPT (trace
-cmp
, SANITIZE_COV_TRACE_CMP
),
1565 #undef COVERAGE_SANITIZER_OPT
1566 { NULL
, 0U, 0UL, false }
1569 /* A struct for describing a run of chars within a string. */
1571 struct string_fragment
1573 string_fragment (const char *start
, size_t len
)
1574 : m_start (start
), m_len (len
) {}
1576 const char *m_start
;
1580 /* Specialization of edit_distance_traits for string_fragment,
1581 for use by get_closest_sanitizer_option. */
1584 struct edit_distance_traits
<const string_fragment
&>
1586 static size_t get_length (const string_fragment
&fragment
)
1588 return fragment
.m_len
;
1591 static const char *get_string (const string_fragment
&fragment
)
1593 return fragment
.m_start
;
1597 /* Given ARG, an unrecognized sanitizer option, return the best
1598 matching sanitizer option, or NULL if there isn't one.
1599 OPTS is array of candidate sanitizer options.
1600 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or
1601 OPT_fsanitize_coverage_.
1602 VALUE is non-zero for the regular form of the option, zero
1603 for the "no-" form (e.g. "-fno-sanitize-recover="). */
1606 get_closest_sanitizer_option (const string_fragment
&arg
,
1607 const struct sanitizer_opts_s
*opts
,
1608 enum opt_code code
, int value
)
1610 best_match
<const string_fragment
&, const char*> bm (arg
);
1611 for (int i
= 0; opts
[i
].name
!= NULL
; ++i
)
1613 /* -fsanitize=all is not valid, so don't offer it. */
1614 if (code
== OPT_fsanitize_
1615 && opts
[i
].flag
== ~0U
1619 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
1620 don't offer the non-recoverable options. */
1621 if (code
== OPT_fsanitize_recover_
1622 && !opts
[i
].can_recover
1626 bm
.consider (opts
[i
].name
);
1628 return bm
.get_best_meaningful_candidate ();
1631 /* Parse comma separated sanitizer suboptions from P for option SCODE,
1632 adjust previous FLAGS and return new ones. If COMPLAIN is false,
1633 don't issue diagnostics. */
1636 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
1637 unsigned int flags
, int value
, bool complain
)
1639 enum opt_code code
= (enum opt_code
) scode
;
1641 const struct sanitizer_opts_s
*opts
;
1642 if (code
== OPT_fsanitize_coverage_
)
1643 opts
= coverage_sanitizer_opts
;
1645 opts
= sanitizer_opts
;
1651 const char *comma
= strchr (p
, ',');
1663 /* Check to see if the string matches an option class name. */
1664 for (i
= 0; opts
[i
].name
!= NULL
; ++i
)
1665 if (len
== opts
[i
].len
&& memcmp (p
, opts
[i
].name
, len
) == 0)
1667 /* Handle both -fsanitize and -fno-sanitize cases. */
1668 if (value
&& opts
[i
].flag
== ~0U)
1670 if (code
== OPT_fsanitize_
)
1673 error_at (loc
, "%<-fsanitize=all%> option is not valid");
1676 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
1677 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
1681 /* Do not enable -fsanitize-recover=unreachable and
1682 -fsanitize-recover=return if -fsanitize-recover=undefined
1684 if (code
== OPT_fsanitize_recover_
1685 && opts
[i
].flag
== SANITIZE_UNDEFINED
)
1686 flags
|= (SANITIZE_UNDEFINED
1687 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
1689 flags
|= opts
[i
].flag
;
1692 flags
&= ~opts
[i
].flag
;
1697 if (! found
&& complain
)
1700 = get_closest_sanitizer_option (string_fragment (p
, len
),
1704 if (code
== OPT_fsanitize_recover_
)
1705 suffix
= "-recover";
1706 else if (code
== OPT_fsanitize_coverage_
)
1707 suffix
= "-coverage";
1713 "unrecognized argument to -f%ssanitize%s= option: %q.*s;"
1714 " did you mean %qs?",
1716 suffix
, (int) len
, p
, hint
);
1719 "unrecognized argument to -f%ssanitize%s= option: %q.*s",
1721 suffix
, (int) len
, p
);
1731 /* Parse string values of no_sanitize attribute passed in VALUE.
1732 Values are separated with comma. */
1735 parse_no_sanitize_attribute (char *value
)
1737 unsigned int flags
= 0;
1739 char *q
= strtok (value
, ",");
1743 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1744 if (strcmp (sanitizer_opts
[i
].name
, q
) == 0)
1746 flags
|= sanitizer_opts
[i
].flag
;
1747 if (sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
1748 flags
|= SANITIZE_UNDEFINED_NONDEFAULT
;
1752 if (sanitizer_opts
[i
].name
== NULL
)
1753 warning (OPT_Wattributes
,
1754 "%<%s%> attribute directive ignored", q
);
1756 q
= strtok (NULL
, ",");
1762 /* Parse -falign-NAME format for a FLAG value. Return individual
1763 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
1764 set, print error message at LOC location. */
1767 parse_and_check_align_values (const char *flag
,
1769 auto_vec
<unsigned> &result_values
,
1773 char *str
= xstrdup (flag
);
1774 for (char *p
= strtok (str
, ":"); p
; p
= strtok (NULL
, ":"))
1777 int v
= strtol (p
, &end
, 10);
1778 if (*end
!= '\0' || v
< 0)
1781 error_at (loc
, "invalid arguments for %<-falign-%s%> option: %qs",
1787 result_values
.safe_push ((unsigned)v
);
1792 /* Check that we have a correct number of values. */
1794 unsigned max_valid_values
= 4;
1796 unsigned max_valid_values
= 2;
1799 if (result_values
.is_empty ()
1800 || result_values
.length () > max_valid_values
)
1803 error_at (loc
, "invalid number of arguments for %<-falign-%s%> "
1804 "option: %qs", name
, flag
);
1808 /* Comes from final.c -- no real reason to change it. */
1809 #define MAX_CODE_ALIGN 16
1810 #define MAX_CODE_ALIGN_VALUE (1 << MAX_CODE_ALIGN)
1812 for (unsigned i
= 0; i
< result_values
.length (); i
++)
1813 if (result_values
[i
] > MAX_CODE_ALIGN_VALUE
)
1816 error_at (loc
, "%<-falign-%s%> is not between 0 and %d",
1817 name
, MAX_CODE_ALIGN_VALUE
);
1824 /* Check that alignment value FLAG for -falign-NAME is valid at a given
1828 check_alignment_argument (location_t loc
, const char *flag
, const char *name
)
1830 auto_vec
<unsigned> align_result
;
1831 parse_and_check_align_values (flag
, name
, align_result
, true, loc
);
1834 /* Handle target- and language-independent options. Return zero to
1835 generate an "unknown option" message. Only options that need
1836 extra handling need to be listed here; if you simply want
1837 DECODED->value assigned to a variable, it happens automatically. */
1840 common_handle_option (struct gcc_options
*opts
,
1841 struct gcc_options
*opts_set
,
1842 const struct cl_decoded_option
*decoded
,
1843 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
1845 const struct cl_option_handlers
*handlers
,
1846 diagnostic_context
*dc
,
1847 void (*target_option_override_hook
) (void))
1849 size_t scode
= decoded
->opt_index
;
1850 const char *arg
= decoded
->arg
;
1851 int value
= decoded
->value
;
1852 enum opt_code code
= (enum opt_code
) scode
;
1854 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
1859 handle_param (opts
, opts_set
, loc
, arg
);
1864 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1865 unsigned int undoc_mask
;
1868 if (lang_mask
== CL_DRIVER
)
1871 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
1874 target_option_override_hook ();
1875 /* First display any single language specific options. */
1876 for (i
= 0; i
< cl_lang_count
; i
++)
1878 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
1880 /* Next display any multi language specific options. */
1881 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
1882 /* Then display any remaining, non-language options. */
1883 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
1885 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
1886 opts
->x_exit_after_options
= true;
1890 case OPT__target_help
:
1891 if (lang_mask
== CL_DRIVER
)
1894 target_option_override_hook ();
1895 print_specific_help (CL_TARGET
, CL_UNDOCUMENTED
, 0, opts
, lang_mask
);
1896 opts
->x_exit_after_options
= true;
1901 const char *a
= arg
;
1902 unsigned int include_flags
= 0;
1903 /* Note - by default we include undocumented options when listing
1904 specific classes. If you only want to see documented options
1905 then add ",^undocumented" to the --help= option. E.g.:
1907 --help=target,^undocumented */
1908 unsigned int exclude_flags
= 0;
1910 if (lang_mask
== CL_DRIVER
)
1913 /* Walk along the argument string, parsing each word in turn.
1915 arg = [^]{word}[,{arg}]
1916 word = {optimizers|target|warnings|undocumented|
1917 params|common|<language>} */
1927 { "optimizers", CL_OPTIMIZATION
},
1928 { "target", CL_TARGET
},
1929 { "warnings", CL_WARNING
},
1930 { "undocumented", CL_UNDOCUMENTED
},
1931 { "params", CL_PARAMS
},
1932 { "joined", CL_JOINED
},
1933 { "separate", CL_SEPARATE
},
1934 { "common", CL_COMMON
},
1937 unsigned int *pflags
;
1939 unsigned int lang_flag
, specific_flag
;
1948 error_at (loc
, "missing argument to %qs", "--help=^");
1951 pflags
= &exclude_flags
;
1954 pflags
= &include_flags
;
1956 comma
= strchr (a
, ',');
1967 /* Check to see if the string matches an option class name. */
1968 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
1969 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
1971 specific_flag
= specifics
[i
].flag
;
1975 /* Check to see if the string matches a language name.
1976 Note - we rely upon the alpha-sorted nature of the entries in
1977 the lang_names array, specifically that shorter names appear
1978 before their longer variants. (i.e. C before C++). That way
1979 when we are attempting to match --help=c for example we will
1980 match with C first and not C++. */
1981 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
1982 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
1984 lang_flag
= 1U << i
;
1988 if (specific_flag
!= 0)
1991 *pflags
|= specific_flag
;
1994 /* The option's argument matches both the start of a
1995 language name and the start of an option class name.
1996 We have a special case for when the user has
1997 specified "--help=c", but otherwise we have to issue
1999 if (strncasecmp (a
, "c", len
) == 0)
2000 *pflags
|= lang_flag
;
2003 "--help argument %q.*s is ambiguous, "
2004 "please be more specific",
2008 else if (lang_flag
!= 0)
2009 *pflags
|= lang_flag
;
2012 "unrecognized argument to --help= option: %q.*s",
2022 target_option_override_hook ();
2023 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
2026 opts
->x_exit_after_options
= true;
2031 if (lang_mask
== CL_DRIVER
)
2034 opts
->x_exit_after_options
= true;
2037 case OPT__completion_
:
2040 case OPT_fsanitize_
:
2041 opts
->x_flag_sanitize
2042 = parse_sanitizer_options (arg
, loc
, code
,
2043 opts
->x_flag_sanitize
, value
, true);
2045 /* Kernel ASan implies normal ASan but does not yet support
2047 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
2049 maybe_set_param_value (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD
,
2050 0, opts
->x_param_values
,
2051 opts_set
->x_param_values
);
2052 maybe_set_param_value (PARAM_ASAN_GLOBALS
, 0, opts
->x_param_values
,
2053 opts_set
->x_param_values
);
2054 maybe_set_param_value (PARAM_ASAN_STACK
, 0, opts
->x_param_values
,
2055 opts_set
->x_param_values
);
2056 maybe_set_param_value (PARAM_ASAN_PROTECT_ALLOCAS
, 0,
2057 opts
->x_param_values
,
2058 opts_set
->x_param_values
);
2059 maybe_set_param_value (PARAM_ASAN_USE_AFTER_RETURN
, 0,
2060 opts
->x_param_values
,
2061 opts_set
->x_param_values
);
2065 case OPT_fsanitize_recover_
:
2066 opts
->x_flag_sanitize_recover
2067 = parse_sanitizer_options (arg
, loc
, code
,
2068 opts
->x_flag_sanitize_recover
, value
, true);
2071 case OPT_fasan_shadow_offset_
:
2075 case OPT_fsanitize_address_use_after_scope
:
2076 opts
->x_flag_sanitize_address_use_after_scope
= value
;
2079 case OPT_fsanitize_recover
:
2081 opts
->x_flag_sanitize_recover
2082 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)
2083 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2085 opts
->x_flag_sanitize_recover
2086 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2089 case OPT_fsanitize_coverage_
:
2090 opts
->x_flag_sanitize_coverage
2091 = parse_sanitizer_options (arg
, loc
, code
,
2092 opts
->x_flag_sanitize_coverage
, value
, true);
2099 /* Currently handled in a prescan. */
2103 dc
->warning_as_error_requested
= value
;
2107 if (lang_mask
== CL_DRIVER
)
2110 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
2111 opts
, opts_set
, loc
, dc
);
2114 case OPT_Wlarger_than_
:
2115 opts
->x_larger_than_size
= value
;
2116 opts
->x_warn_larger_than
= value
!= -1;
2119 case OPT_Wfatal_errors
:
2120 dc
->fatal_errors
= value
;
2123 case OPT_Wframe_larger_than_
:
2124 opts
->x_frame_larger_than_size
= value
;
2125 opts
->x_warn_frame_larger_than
= value
!= -1;
2128 case OPT_Wstack_usage_
:
2129 opts
->x_warn_stack_usage
= value
;
2130 opts
->x_flag_stack_usage_info
= value
!= -1;
2133 case OPT_Wstrict_aliasing
:
2134 set_Wstrict_aliasing (opts
, value
);
2137 case OPT_Wstrict_overflow
:
2138 opts
->x_warn_strict_overflow
= (value
2139 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2143 case OPT_Wsystem_headers
:
2144 dc
->dc_warn_system_headers
= value
;
2148 opts
->x_flag_gen_aux_info
= 1;
2151 case OPT_auxbase_strip
:
2153 char *tmp
= xstrdup (arg
);
2154 strip_off_ending (tmp
, strlen (tmp
));
2156 opts
->x_aux_base_name
= tmp
;
2163 decode_d_option (arg
, opts
, loc
, dc
);
2166 case OPT_fcall_used_
:
2167 case OPT_fcall_saved_
:
2175 case OPT_fdbg_cnt_list
:
2177 opts
->x_exit_after_options
= true;
2180 case OPT_fdebug_prefix_map_
:
2181 case OPT_ffile_prefix_map_
:
2185 case OPT_fdiagnostics_show_location_
:
2186 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2189 case OPT_fdiagnostics_show_caret
:
2190 dc
->show_caret
= value
;
2193 case OPT_fdiagnostics_color_
:
2194 diagnostic_color_init (dc
, value
);
2197 case OPT_fdiagnostics_parseable_fixits
:
2198 dc
->parseable_fixits_p
= value
;
2201 case OPT_fdiagnostics_show_option
:
2202 dc
->show_option_requested
= value
;
2209 case OPT_ffast_math
:
2210 set_fast_math_flags (opts
, value
);
2213 case OPT_funsafe_math_optimizations
:
2214 set_unsafe_math_optimizations_flags (opts
, value
);
2221 case OPT_finline_limit_
:
2222 set_param_value ("max-inline-insns-single", value
/ 2,
2223 opts
->x_param_values
, opts_set
->x_param_values
);
2224 set_param_value ("max-inline-insns-auto", value
/ 2,
2225 opts
->x_param_values
, opts_set
->x_param_values
);
2228 case OPT_finstrument_functions_exclude_function_list_
:
2229 add_comma_separated_to_vector
2230 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2233 case OPT_finstrument_functions_exclude_file_list_
:
2234 add_comma_separated_to_vector
2235 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2238 case OPT_fmessage_length_
:
2239 pp_set_line_maximum_length (dc
->printer
, value
);
2240 diagnostic_set_caret_max_width (dc
, value
);
2244 case OPT_fopt_info_
:
2250 const char *p
= arg
;
2251 opts
->x_flag_disable_hsa
= true;
2254 const char *comma
= strchr (p
, ',');
2256 if ((strncmp (p
, "disable", 7) == 0)
2257 && (p
[7] == ',' || p
[7] == '\0'))
2259 opts
->x_flag_disable_hsa
= true;
2263 if ((strncmp (p
, "hsa", 3) == 0)
2264 && (p
[3] == ',' || p
[3] == '\0'))
2267 opts
->x_flag_disable_hsa
= false;
2269 sorry ("HSA has not been enabled during configuration");
2279 #ifndef ACCEL_COMPILER
2280 case OPT_foffload_abi_
:
2281 error_at (loc
, "%<-foffload-abi%> option can be specified only for "
2282 "offload compiler");
2286 case OPT_fpack_struct_
:
2287 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2289 "structure alignment must be a small power of two, not %d",
2292 opts
->x_initial_max_fld_align
= value
;
2296 case OPT_fplugin_arg_
:
2300 case OPT_fprofile_use_
:
2301 opts
->x_profile_data_prefix
= xstrdup (arg
);
2302 opts
->x_flag_profile_use
= true;
2304 /* No break here - do -fprofile-use processing. */
2306 case OPT_fprofile_use
:
2307 enable_fdo_optimizations (opts
, opts_set
, value
);
2308 if (!opts_set
->x_flag_profile_reorder_functions
)
2309 opts
->x_flag_profile_reorder_functions
= value
;
2310 /* Indirect call profiling should do all useful transformations
2311 speculative devirtualization does. */
2312 if (!opts_set
->x_flag_devirtualize_speculatively
2313 && opts
->x_flag_value_profile_transformations
)
2314 opts
->x_flag_devirtualize_speculatively
= false;
2317 case OPT_fauto_profile_
:
2318 opts
->x_auto_profile_file
= xstrdup (arg
);
2319 opts
->x_flag_auto_profile
= true;
2321 /* No break here - do -fauto-profile processing. */
2323 case OPT_fauto_profile
:
2324 enable_fdo_optimizations (opts
, opts_set
, value
);
2325 if (!opts_set
->x_flag_profile_correction
)
2326 opts
->x_flag_profile_correction
= value
;
2327 maybe_set_param_value (
2328 PARAM_EARLY_INLINER_MAX_ITERATIONS
, 10,
2329 opts
->x_param_values
, opts_set
->x_param_values
);
2332 case OPT_fprofile_generate_
:
2333 opts
->x_profile_data_prefix
= xstrdup (arg
);
2335 /* No break here - do -fprofile-generate processing. */
2337 case OPT_fprofile_generate
:
2338 if (!opts_set
->x_profile_arc_flag
)
2339 opts
->x_profile_arc_flag
= value
;
2340 if (!opts_set
->x_flag_profile_values
)
2341 opts
->x_flag_profile_values
= value
;
2342 if (!opts_set
->x_flag_inline_functions
)
2343 opts
->x_flag_inline_functions
= value
;
2344 if (!opts_set
->x_flag_ipa_bit_cp
)
2345 opts
->x_flag_ipa_bit_cp
= value
;
2346 /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
2347 quadratic. Disable the pass until better memory representation
2349 if (!opts_set
->x_flag_ipa_reference
)
2350 opts
->x_flag_ipa_reference
= false;
2353 case OPT_fpatchable_function_entry_
:
2355 char *patch_area_arg
= xstrdup (arg
);
2356 char *comma
= strchr (patch_area_arg
, ',');
2360 function_entry_patch_area_size
=
2361 integral_argument (patch_area_arg
);
2362 function_entry_patch_area_start
=
2363 integral_argument (comma
+ 1);
2367 function_entry_patch_area_size
=
2368 integral_argument (patch_area_arg
);
2369 function_entry_patch_area_start
= 0;
2371 if (function_entry_patch_area_size
< 0
2372 || function_entry_patch_area_start
< 0
2373 || function_entry_patch_area_size
2374 < function_entry_patch_area_start
)
2375 error ("invalid arguments for %<-fpatchable_function_entry%>");
2376 free (patch_area_arg
);
2380 case OPT_ftree_vectorize
:
2381 /* Automatically sets -ftree-loop-vectorize and
2382 -ftree-slp-vectorize. Nothing more to do here. */
2384 case OPT_fshow_column
:
2385 dc
->show_column
= value
;
2388 case OPT_frandom_seed
:
2389 /* The real switch is -fno-random-seed. */
2395 case OPT_frandom_seed_
:
2399 case OPT_fsched_verbose_
:
2400 #ifdef INSN_SCHEDULING
2401 /* Handled with Var in common.opt. */
2407 case OPT_fsched_stalled_insns_
:
2408 opts
->x_flag_sched_stalled_insns
= value
;
2409 if (opts
->x_flag_sched_stalled_insns
== 0)
2410 opts
->x_flag_sched_stalled_insns
= -1;
2413 case OPT_fsched_stalled_insns_dep_
:
2414 opts
->x_flag_sched_stalled_insns_dep
= value
;
2417 case OPT_fstack_check_
:
2418 if (!strcmp (arg
, "no"))
2419 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
2420 else if (!strcmp (arg
, "generic"))
2421 /* This is the old stack checking method. */
2422 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2423 ? FULL_BUILTIN_STACK_CHECK
2424 : GENERIC_STACK_CHECK
;
2425 else if (!strcmp (arg
, "specific"))
2426 /* This is the new stack checking method. */
2427 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2428 ? FULL_BUILTIN_STACK_CHECK
2429 : STACK_CHECK_STATIC_BUILTIN
2430 ? STATIC_BUILTIN_STACK_CHECK
2431 : GENERIC_STACK_CHECK
;
2433 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
2436 case OPT_fstack_limit
:
2437 /* The real switch is -fno-stack-limit. */
2443 case OPT_fstack_limit_register_
:
2444 case OPT_fstack_limit_symbol_
:
2448 case OPT_fstack_usage
:
2449 opts
->x_flag_stack_usage
= value
;
2450 opts
->x_flag_stack_usage_info
= value
!= 0;
2454 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
2459 if (arg
&& strlen (arg
) != 0)
2461 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
2462 "use %<-gdwarf-%s%> for DWARF version "
2463 "or %<-gdwarf -g%s%> for debug level", arg
, arg
, arg
);
2467 value
= opts
->x_dwarf_version
;
2471 if (value
< 2 || value
> 5)
2472 error_at (loc
, "dwarf version %d is not supported", value
);
2474 opts
->x_dwarf_version
= value
;
2475 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
2478 case OPT_gsplit_dwarf
:
2479 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, "", opts
, opts_set
,
2484 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
2489 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
, opts
, opts_set
,
2494 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2499 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
, opts
, opts_set
,
2505 /* Handled completely via specs. */
2508 case OPT_pedantic_errors
:
2509 dc
->pedantic_errors
= 1;
2510 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
2512 handlers
, opts
, opts_set
,
2517 opts
->x_flag_lto
= value
? "" : NULL
;
2521 dc
->dc_inhibit_warnings
= true;
2524 case OPT_fmax_errors_
:
2525 dc
->max_errors
= value
;
2528 case OPT_fuse_ld_bfd
:
2529 case OPT_fuse_ld_gold
:
2530 case OPT_fuse_linker_plugin
:
2531 /* No-op. Used by the driver and passed to us because it starts with f.*/
2536 opts
->x_flag_trapv
= 0;
2541 opts
->x_flag_wrapv
= 0;
2544 case OPT_fstrict_overflow
:
2545 opts
->x_flag_wrapv
= !value
;
2546 opts
->x_flag_wrapv_pointer
= !value
;
2548 opts
->x_flag_trapv
= 0;
2552 opts
->x_flag_ipa_icf_functions
= value
;
2553 opts
->x_flag_ipa_icf_variables
= value
;
2556 case OPT_falign_loops_
:
2557 check_alignment_argument (loc
, arg
, "loops");
2560 case OPT_falign_jumps_
:
2561 check_alignment_argument (loc
, arg
, "jumps");
2564 case OPT_falign_labels_
:
2565 check_alignment_argument (loc
, arg
, "labels");
2568 case OPT_falign_functions_
:
2569 check_alignment_argument (loc
, arg
, "functions");
2573 /* If the flag was handled in a standard way, assume the lack of
2574 processing here is intentional. */
2575 gcc_assert (option_flag_var (scode
, opts
));
2579 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
2584 /* Handle --param NAME=VALUE. */
2586 handle_param (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2587 location_t loc
, const char *carg
)
2592 arg
= xstrdup (carg
);
2593 equal
= strchr (arg
, '=');
2595 error_at (loc
, "%s: --param arguments should be of the form NAME=VALUE",
2601 enum compiler_param index
;
2602 if (!find_param (arg
, &index
))
2604 const char *suggestion
= find_param_fuzzy (arg
);
2606 error_at (loc
, "invalid --param name %qs; did you mean %qs?",
2609 error_at (loc
, "invalid --param name %qs", arg
);
2613 if (!param_string_value_p (index
, equal
+ 1, &value
))
2614 value
= integral_argument (equal
+ 1);
2617 error_at (loc
, "invalid --param value %qs", equal
+ 1);
2619 set_param_value (arg
, value
,
2620 opts
->x_param_values
, opts_set
->x_param_values
);
2627 /* Used to set the level of strict aliasing warnings in OPTS,
2628 when no level is specified (i.e., when -Wstrict-aliasing, and not
2629 -Wstrict-aliasing=level was given).
2630 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2631 and 0 otherwise. After calling this function, wstrict_aliasing will be
2632 set to the default value of -Wstrict_aliasing=level, currently 3. */
2634 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
2636 gcc_assert (onoff
== 0 || onoff
== 1);
2638 opts
->x_warn_strict_aliasing
= 3;
2640 opts
->x_warn_strict_aliasing
= 0;
2643 /* The following routines are useful in setting all the flags that
2644 -ffast-math and -fno-fast-math imply. */
2646 set_fast_math_flags (struct gcc_options
*opts
, int set
)
2648 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
2650 opts
->x_flag_unsafe_math_optimizations
= set
;
2651 set_unsafe_math_optimizations_flags (opts
, set
);
2653 if (!opts
->frontend_set_flag_finite_math_only
)
2654 opts
->x_flag_finite_math_only
= set
;
2655 if (!opts
->frontend_set_flag_errno_math
)
2656 opts
->x_flag_errno_math
= !set
;
2659 if (opts
->frontend_set_flag_excess_precision_cmdline
2660 == EXCESS_PRECISION_DEFAULT
)
2661 opts
->x_flag_excess_precision_cmdline
2662 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
2663 if (!opts
->frontend_set_flag_signaling_nans
)
2664 opts
->x_flag_signaling_nans
= 0;
2665 if (!opts
->frontend_set_flag_rounding_math
)
2666 opts
->x_flag_rounding_math
= 0;
2667 if (!opts
->frontend_set_flag_cx_limited_range
)
2668 opts
->x_flag_cx_limited_range
= 1;
2672 /* When -funsafe-math-optimizations is set the following
2673 flags are set as well. */
2675 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
2677 if (!opts
->frontend_set_flag_trapping_math
)
2678 opts
->x_flag_trapping_math
= !set
;
2679 if (!opts
->frontend_set_flag_signed_zeros
)
2680 opts
->x_flag_signed_zeros
= !set
;
2681 if (!opts
->frontend_set_flag_associative_math
)
2682 opts
->x_flag_associative_math
= set
;
2683 if (!opts
->frontend_set_flag_reciprocal_math
)
2684 opts
->x_flag_reciprocal_math
= set
;
2687 /* Return true iff flags in OPTS are set as if -ffast-math. */
2689 fast_math_flags_set_p (const struct gcc_options
*opts
)
2691 return (!opts
->x_flag_trapping_math
2692 && opts
->x_flag_unsafe_math_optimizations
2693 && opts
->x_flag_finite_math_only
2694 && !opts
->x_flag_signed_zeros
2695 && !opts
->x_flag_errno_math
2696 && opts
->x_flag_excess_precision_cmdline
2697 == EXCESS_PRECISION_FAST
);
2700 /* Return true iff flags are set as if -ffast-math but using the flags stored
2701 in the struct cl_optimization structure. */
2703 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
2705 return (!opt
->x_flag_trapping_math
2706 && opt
->x_flag_unsafe_math_optimizations
2707 && opt
->x_flag_finite_math_only
2708 && !opt
->x_flag_signed_zeros
2709 && !opt
->x_flag_errno_math
);
2712 /* Handle a debug output -g switch for options OPTS
2713 (OPTS_SET->x_write_symbols storing whether a debug type was passed
2714 explicitly), location LOC. EXTENDED is true or false to support
2715 extended output (2 is special and means "-ggdb" was given). */
2717 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
,
2718 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2721 opts
->x_use_gnu_debug_info_extensions
= extended
;
2723 if (type
== NO_DEBUG
)
2725 if (opts
->x_write_symbols
== NO_DEBUG
)
2727 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
2731 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
2732 opts
->x_write_symbols
= DWARF2_DEBUG
;
2733 #elif defined DBX_DEBUGGING_INFO
2734 opts
->x_write_symbols
= DBX_DEBUG
;
2738 if (opts
->x_write_symbols
== NO_DEBUG
)
2739 warning_at (loc
, 0, "target system does not support debug output");
2744 /* Does it conflict with an already selected type? */
2745 if (opts_set
->x_write_symbols
!= NO_DEBUG
2746 && opts
->x_write_symbols
!= NO_DEBUG
2747 && type
!= opts
->x_write_symbols
)
2748 error_at (loc
, "debug format %qs conflicts with prior selection",
2749 debug_type_names
[type
]);
2750 opts
->x_write_symbols
= type
;
2751 opts_set
->x_write_symbols
= type
;
2754 /* A debug flag without a level defaults to level 2.
2755 If off or at level 1, set it to level 2, but if already
2756 at level 3, don't lower it. */
2759 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
2760 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
2764 int argval
= integral_argument (arg
);
2766 error_at (loc
, "unrecognized debug output level %qs", arg
);
2767 else if (argval
> 3)
2768 error_at (loc
, "debug output level %qs is too high", arg
);
2770 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
2774 /* Arrange to dump core on error for diagnostic context DC. (The
2775 regular error message is still printed first, except in the case of
2779 setup_core_dumping (diagnostic_context
*dc
)
2782 signal (SIGABRT
, SIG_DFL
);
2784 #if defined(HAVE_SETRLIMIT)
2787 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
2788 fatal_error (input_location
, "getting core file size maximum limit: %m");
2789 rlim
.rlim_cur
= rlim
.rlim_max
;
2790 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
2791 fatal_error (input_location
,
2792 "setting core file size limit to maximum: %m");
2795 diagnostic_abort_on_error (dc
);
2798 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
2799 diagnostic context DC. */
2802 decode_d_option (const char *arg
, struct gcc_options
*opts
,
2803 location_t loc
, diagnostic_context
*dc
)
2811 opts
->x_flag_debug_asm
= 1;
2814 opts
->x_flag_print_asm_name
= 1;
2817 opts
->x_flag_dump_rtl_in_asm
= 1;
2818 opts
->x_flag_print_asm_name
= 1;
2821 opts
->x_rtl_dump_and_exit
= 1;
2823 case 'D': /* These are handled by the preprocessor. */
2830 setup_core_dumping (dc
);
2833 opts
->x_flag_dump_all_passed
= true;
2837 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
2842 /* Enable (or disable if VALUE is 0) a warning option ARG (language
2843 mask LANG_MASK, option handlers HANDLERS) as an error for option
2844 structures OPTS and OPTS_SET, diagnostic context DC (possibly
2845 NULL), location LOC. This is used by -Werror=. */
2848 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
2849 const struct cl_option_handlers
*handlers
,
2850 struct gcc_options
*opts
,
2851 struct gcc_options
*opts_set
,
2852 location_t loc
, diagnostic_context
*dc
)
2857 new_option
= XNEWVEC (char, strlen (arg
) + 2);
2858 new_option
[0] = 'W';
2859 strcpy (new_option
+ 1, arg
);
2860 option_index
= find_opt (new_option
, lang_mask
);
2861 if (option_index
== OPT_SPECIAL_unknown
)
2862 error_at (loc
, "-Werror=%s: no option -%s", arg
, new_option
);
2863 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
2864 error_at (loc
, "-Werror=%s: -%s is not an option that controls warnings",
2868 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
2869 const char *arg
= NULL
;
2871 if (cl_options
[option_index
].flags
& CL_JOINED
)
2872 arg
= new_option
+ cl_options
[option_index
].opt_len
;
2873 control_warning_option (option_index
, (int) kind
, arg
, value
,
2875 handlers
, opts
, opts_set
, dc
);
2880 /* Return malloced memory for the name of the option OPTION_INDEX
2881 which enabled a diagnostic (context CONTEXT), originally of type
2882 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2886 option_name (diagnostic_context
*context
, int option_index
,
2887 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
2891 /* A warning classified as an error. */
2892 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
2893 && diag_kind
== DK_ERROR
)
2894 return concat (cl_options
[OPT_Werror_
].opt_text
,
2895 /* Skip over "-W". */
2896 cl_options
[option_index
].opt_text
+ 2,
2898 /* A warning with option. */
2900 return xstrdup (cl_options
[option_index
].opt_text
);
2902 /* A warning without option classified as an error. */
2903 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
2904 || diag_kind
== DK_WARNING
)
2905 && context
->warning_as_error_requested
)
2906 return xstrdup (cl_options
[OPT_Werror
].opt_text
);