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_NOT_DEBUG
, 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_reference_addressable
, NULL
, 1 },
455 { OPT_LEVELS_1_PLUS
, OPT_fipa_profile
, NULL
, 1 },
456 { OPT_LEVELS_1_PLUS
, OPT_fmerge_constants
, NULL
, 1 },
457 { OPT_LEVELS_1_PLUS
, OPT_freorder_blocks
, NULL
, 1 },
458 { OPT_LEVELS_1_PLUS
, OPT_fshrink_wrap
, NULL
, 1 },
459 { OPT_LEVELS_1_PLUS
, OPT_fsplit_wide_types
, NULL
, 1 },
460 { OPT_LEVELS_1_PLUS
, OPT_ftree_ccp
, NULL
, 1 },
461 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_bit_ccp
, NULL
, 1 },
462 { OPT_LEVELS_1_PLUS
, OPT_ftree_coalesce_vars
, NULL
, 1 },
463 { OPT_LEVELS_1_PLUS
, OPT_ftree_dce
, NULL
, 1 },
464 { OPT_LEVELS_1_PLUS
, OPT_ftree_dominator_opts
, NULL
, 1 },
465 { OPT_LEVELS_1_PLUS
, OPT_ftree_dse
, NULL
, 1 },
466 { OPT_LEVELS_1_PLUS
, OPT_ftree_ter
, NULL
, 1 },
467 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_sra
, NULL
, 1 },
468 { OPT_LEVELS_1_PLUS
, OPT_ftree_fre
, NULL
, 1 },
469 { OPT_LEVELS_1_PLUS
, OPT_ftree_copy_prop
, NULL
, 1 },
470 { OPT_LEVELS_1_PLUS
, OPT_ftree_sink
, NULL
, 1 },
471 { OPT_LEVELS_1_PLUS
, OPT_ftree_ch
, NULL
, 1 },
472 { OPT_LEVELS_1_PLUS
, OPT_fcombine_stack_adjustments
, NULL
, 1 },
473 { OPT_LEVELS_1_PLUS
, OPT_fcompare_elim
, NULL
, 1 },
474 { OPT_LEVELS_1_PLUS
, OPT_ftree_slsr
, NULL
, 1 },
475 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fbranch_count_reg
, NULL
, 1 },
476 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_invariants
, NULL
, 1 },
477 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_pta
, NULL
, 1 },
478 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fssa_phiopt
, NULL
, 1 },
479 { OPT_LEVELS_1_PLUS
, OPT_ftree_builtin_call_dce
, NULL
, 1 },
480 { OPT_LEVELS_1_PLUS
, OPT_fomit_frame_pointer
, NULL
, 1 },
482 /* -O2 optimizations. */
483 { OPT_LEVELS_2_PLUS
, OPT_finline_small_functions
, NULL
, 1 },
484 { OPT_LEVELS_2_PLUS
, OPT_findirect_inlining
, NULL
, 1 },
485 { OPT_LEVELS_2_PLUS
, OPT_fpartial_inlining
, NULL
, 1 },
486 { OPT_LEVELS_2_PLUS
, OPT_fthread_jumps
, NULL
, 1 },
487 { OPT_LEVELS_2_PLUS
, OPT_fcrossjumping
, NULL
, 1 },
488 { OPT_LEVELS_2_PLUS
, OPT_foptimize_sibling_calls
, NULL
, 1 },
489 { OPT_LEVELS_2_PLUS
, OPT_fcse_follow_jumps
, NULL
, 1 },
490 { OPT_LEVELS_2_PLUS
, OPT_fgcse
, NULL
, 1 },
491 { OPT_LEVELS_2_PLUS
, OPT_fexpensive_optimizations
, NULL
, 1 },
492 { OPT_LEVELS_2_PLUS
, OPT_frerun_cse_after_loop
, NULL
, 1 },
493 { OPT_LEVELS_2_PLUS
, OPT_fcaller_saves
, NULL
, 1 },
494 { OPT_LEVELS_2_PLUS
, OPT_fpeephole2
, NULL
, 1 },
495 #ifdef INSN_SCHEDULING
496 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
497 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_fschedule_insns
, NULL
, 1 },
498 { OPT_LEVELS_2_PLUS
, OPT_fschedule_insns2
, NULL
, 1 },
500 { OPT_LEVELS_2_PLUS
, OPT_fstrict_aliasing
, NULL
, 1 },
501 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_freorder_blocks_algorithm_
, NULL
,
502 REORDER_BLOCKS_ALGORITHM_STC
},
503 { OPT_LEVELS_2_PLUS
, OPT_freorder_functions
, NULL
, 1 },
504 { OPT_LEVELS_2_PLUS
, OPT_ftree_vrp
, NULL
, 1 },
505 { OPT_LEVELS_2_PLUS
, OPT_fcode_hoisting
, NULL
, 1 },
506 { OPT_LEVELS_2_PLUS
, OPT_ftree_pre
, NULL
, 1 },
507 { OPT_LEVELS_2_PLUS
, OPT_ftree_switch_conversion
, NULL
, 1 },
508 { OPT_LEVELS_2_PLUS
, OPT_fipa_cp
, NULL
, 1 },
509 { OPT_LEVELS_2_PLUS
, OPT_fipa_bit_cp
, NULL
, 1 },
510 { OPT_LEVELS_2_PLUS
, OPT_fipa_vrp
, NULL
, 1 },
511 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize
, NULL
, 1 },
512 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize_speculatively
, NULL
, 1 },
513 { OPT_LEVELS_2_PLUS
, OPT_fipa_sra
, NULL
, 1 },
514 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_loops
, NULL
, 1 },
515 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_jumps
, NULL
, 1 },
516 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_labels
, NULL
, 1 },
517 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_falign_functions
, NULL
, 1 },
518 { OPT_LEVELS_2_PLUS
, OPT_ftree_tail_merge
, NULL
, 1 },
519 { OPT_LEVELS_2_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_CHEAP
},
520 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_foptimize_strlen
, NULL
, 1 },
521 { OPT_LEVELS_2_PLUS
, OPT_fhoist_adjacent_loads
, NULL
, 1 },
522 { OPT_LEVELS_2_PLUS
, OPT_fipa_icf
, NULL
, 1 },
523 { OPT_LEVELS_2_PLUS
, OPT_fisolate_erroneous_paths_dereference
, NULL
, 1 },
524 { OPT_LEVELS_2_PLUS
, OPT_fipa_ra
, NULL
, 1 },
525 { OPT_LEVELS_2_PLUS
, OPT_flra_remat
, NULL
, 1 },
526 { OPT_LEVELS_2_PLUS
, OPT_fstore_merging
, NULL
, 1 },
528 /* -O3 optimizations. */
529 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribute_patterns
, NULL
, 1 },
530 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribution
, NULL
, 1 },
531 { OPT_LEVELS_3_PLUS
, OPT_floop_interchange
, NULL
, 1 },
532 { OPT_LEVELS_3_PLUS
, OPT_fpredictive_commoning
, NULL
, 1 },
533 { OPT_LEVELS_3_PLUS
, OPT_fsplit_paths
, NULL
, 1 },
534 /* Inlining of functions reducing size is a good idea with -Os
535 regardless of them being declared inline. */
536 { OPT_LEVELS_3_PLUS_AND_SIZE
, OPT_finline_functions
, NULL
, 1 },
537 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_finline_functions_called_once
, NULL
, 1 },
538 { OPT_LEVELS_3_PLUS
, OPT_fsplit_loops
, NULL
, 1 },
539 { OPT_LEVELS_3_PLUS
, OPT_funswitch_loops
, NULL
, 1 },
540 { OPT_LEVELS_3_PLUS
, OPT_floop_unroll_and_jam
, NULL
, 1 },
541 { OPT_LEVELS_3_PLUS
, OPT_fgcse_after_reload
, NULL
, 1 },
542 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_vectorize
, NULL
, 1 },
543 { OPT_LEVELS_3_PLUS
, OPT_ftree_slp_vectorize
, NULL
, 1 },
544 { OPT_LEVELS_3_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_DYNAMIC
},
545 { OPT_LEVELS_3_PLUS
, OPT_fipa_cp_clone
, NULL
, 1 },
546 { OPT_LEVELS_3_PLUS
, OPT_ftree_partial_pre
, NULL
, 1 },
547 { OPT_LEVELS_3_PLUS
, OPT_fpeel_loops
, NULL
, 1 },
549 /* -Ofast adds optimizations to -O3. */
550 { OPT_LEVELS_FAST
, OPT_ffast_math
, NULL
, 1 },
552 { OPT_LEVELS_NONE
, 0, NULL
, 0 }
555 /* Default the options in OPTS and OPTS_SET based on the optimization
556 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
558 default_options_optimization (struct gcc_options
*opts
,
559 struct gcc_options
*opts_set
,
560 struct cl_decoded_option
*decoded_options
,
561 unsigned int decoded_options_count
,
563 unsigned int lang_mask
,
564 const struct cl_option_handlers
*handlers
,
565 diagnostic_context
*dc
)
569 bool openacc_mode
= false;
571 /* Scan to see what optimization level has been specified. That will
572 determine the default value of many flags. */
573 for (i
= 1; i
< decoded_options_count
; i
++)
575 struct cl_decoded_option
*opt
= &decoded_options
[i
];
576 switch (opt
->opt_index
)
579 if (*opt
->arg
== '\0')
581 opts
->x_optimize
= 1;
582 opts
->x_optimize_size
= 0;
583 opts
->x_optimize_fast
= 0;
584 opts
->x_optimize_debug
= 0;
588 const int optimize_val
= integral_argument (opt
->arg
);
589 if (optimize_val
== -1)
590 error_at (loc
, "argument to %<-O%> should be a non-negative "
591 "integer, %<g%>, %<s%> or %<fast%>");
594 opts
->x_optimize
= optimize_val
;
595 if ((unsigned int) opts
->x_optimize
> 255)
596 opts
->x_optimize
= 255;
597 opts
->x_optimize_size
= 0;
598 opts
->x_optimize_fast
= 0;
599 opts
->x_optimize_debug
= 0;
605 opts
->x_optimize_size
= 1;
607 /* Optimizing for size forces optimize to be 2. */
608 opts
->x_optimize
= 2;
609 opts
->x_optimize_fast
= 0;
610 opts
->x_optimize_debug
= 0;
614 /* -Ofast only adds flags to -O3. */
615 opts
->x_optimize_size
= 0;
616 opts
->x_optimize
= 3;
617 opts
->x_optimize_fast
= 1;
618 opts
->x_optimize_debug
= 0;
622 /* -Og selects optimization level 1. */
623 opts
->x_optimize_size
= 0;
624 opts
->x_optimize
= 1;
625 opts
->x_optimize_fast
= 0;
626 opts
->x_optimize_debug
= 1;
635 /* Ignore other options in this prescan. */
640 maybe_default_options (opts
, opts_set
, default_options_table
,
641 opts
->x_optimize
, opts
->x_optimize_size
,
642 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
643 lang_mask
, handlers
, loc
, dc
);
645 /* -O2 param settings. */
646 opt2
= (opts
->x_optimize
>= 2);
649 && !opts_set
->x_flag_ipa_pta
)
650 opts
->x_flag_ipa_pta
= true;
652 /* Track fields in field-sensitive alias analysis. */
653 maybe_set_param_value
654 (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
,
655 opt2
? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
),
656 opts
->x_param_values
, opts_set
->x_param_values
);
658 /* For -O1 only do loop invariant motion for very small loops. */
659 maybe_set_param_value
660 (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
,
661 opt2
? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
) : 1000,
662 opts
->x_param_values
, opts_set
->x_param_values
);
664 /* At -Ofast, allow store motion to introduce potential race conditions. */
665 maybe_set_param_value
666 (PARAM_ALLOW_STORE_DATA_RACES
,
667 opts
->x_optimize_fast
? 1
668 : default_param_value (PARAM_ALLOW_STORE_DATA_RACES
),
669 opts
->x_param_values
, opts_set
->x_param_values
);
671 if (opts
->x_optimize_size
)
672 /* We want to crossjump as much as possible. */
673 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
, 1,
674 opts
->x_param_values
, opts_set
->x_param_values
);
676 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
,
677 default_param_value (PARAM_MIN_CROSSJUMP_INSNS
),
678 opts
->x_param_values
, opts_set
->x_param_values
);
680 /* Restrict the amount of work combine does at -Og while retaining
681 most of its useful transforms. */
682 if (opts
->x_optimize_debug
)
683 maybe_set_param_value (PARAM_MAX_COMBINE_INSNS
, 2,
684 opts
->x_param_values
, opts_set
->x_param_values
);
686 /* Allow default optimizations to be specified on a per-machine basis. */
687 maybe_default_options (opts
, opts_set
,
688 targetm_common
.option_optimization_table
,
689 opts
->x_optimize
, opts
->x_optimize_size
,
690 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
691 lang_mask
, handlers
, loc
, dc
);
694 /* After all options at LOC have been read into OPTS and OPTS_SET,
695 finalize settings of those options and diagnose incompatible
698 finish_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
701 enum unwind_info_type ui_except
;
703 if (opts
->x_dump_base_name
704 && ! opts
->x_dump_base_name_prefixed
)
706 const char *sep
= opts
->x_dump_base_name
;
709 if (IS_DIR_SEPARATOR (*sep
))
713 /* If dump_base_path contains subdirectories, don't prepend
715 else if (opts
->x_dump_dir_name
)
716 /* We have a DUMP_DIR_NAME, prepend that. */
717 opts
->x_dump_base_name
= opts_concat (opts
->x_dump_dir_name
,
718 opts
->x_dump_base_name
, NULL
);
719 else if (opts
->x_aux_base_name
720 && strcmp (opts
->x_aux_base_name
, HOST_BIT_BUCKET
) != 0)
721 /* AUX_BASE_NAME is set and is not the bit bucket. If it
722 contains a directory component, prepend those directories.
723 Typically this places things in the same directory as the
726 const char *aux_base
;
728 base_of_path (opts
->x_aux_base_name
, &aux_base
);
729 if (opts
->x_aux_base_name
!= aux_base
)
731 int dir_len
= aux_base
- opts
->x_aux_base_name
;
732 char *new_dump_base_name
733 = XOBNEWVEC (&opts_obstack
, char,
734 strlen (opts
->x_dump_base_name
) + dir_len
+ 1);
736 /* Copy directory component from OPTS->X_AUX_BASE_NAME. */
737 memcpy (new_dump_base_name
, opts
->x_aux_base_name
, dir_len
);
738 /* Append existing OPTS->X_DUMP_BASE_NAME. */
739 strcpy (new_dump_base_name
+ dir_len
, opts
->x_dump_base_name
);
740 opts
->x_dump_base_name
= new_dump_base_name
;
744 /* It is definitely prefixed now. */
745 opts
->x_dump_base_name_prefixed
= true;
748 /* Handle related options for unit-at-a-time, toplevel-reorder, and
750 if (!opts
->x_flag_unit_at_a_time
)
752 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
753 error_at (loc
, "section anchors must be disabled when unit-at-a-time "
755 opts
->x_flag_section_anchors
= 0;
756 if (opts
->x_flag_toplevel_reorder
== 1)
757 error_at (loc
, "toplevel reorder must be disabled when unit-at-a-time "
759 opts
->x_flag_toplevel_reorder
= 0;
762 /* -fself-test depends on the state of the compiler prior to
763 compiling anything. Ideally it should be run on an empty source
764 file. However, in case we get run with actual source, assume
765 -fsyntax-only which will inhibit any compiler initialization
766 which may confuse the self tests. */
767 if (opts
->x_flag_self_test
)
768 opts
->x_flag_syntax_only
= 1;
770 if (opts
->x_flag_tm
&& opts
->x_flag_non_call_exceptions
)
771 sorry ("transactional memory is not supported with non-call exceptions");
773 /* Unless the user has asked for section anchors, we disable toplevel
774 reordering at -O0 to disable transformations that might be surprising
775 to end users and to get -fno-toplevel-reorder tested. */
776 if (!opts
->x_optimize
777 && opts
->x_flag_toplevel_reorder
== 2
778 && !(opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
))
780 opts
->x_flag_toplevel_reorder
= 0;
781 opts
->x_flag_section_anchors
= 0;
783 if (!opts
->x_flag_toplevel_reorder
)
785 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
786 error_at (loc
, "section anchors must be disabled when toplevel reorder"
788 opts
->x_flag_section_anchors
= 0;
791 if (!opts
->x_flag_opts_finished
)
793 /* We initialize opts->x_flag_pie to -1 so that targets can set a
795 if (opts
->x_flag_pie
== -1)
797 /* We initialize opts->x_flag_pic to -1 so that we can tell if
798 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
799 if (opts
->x_flag_pic
== -1)
800 opts
->x_flag_pie
= DEFAULT_FLAG_PIE
;
802 opts
->x_flag_pie
= 0;
804 /* If -fPIE or -fpie is used, turn on PIC. */
805 if (opts
->x_flag_pie
)
806 opts
->x_flag_pic
= opts
->x_flag_pie
;
807 else if (opts
->x_flag_pic
== -1)
808 opts
->x_flag_pic
= 0;
809 if (opts
->x_flag_pic
&& !opts
->x_flag_pie
)
810 opts
->x_flag_shlib
= 1;
811 opts
->x_flag_opts_finished
= true;
814 /* We initialize opts->x_flag_stack_protect to -1 so that targets
815 can set a default value. */
816 if (opts
->x_flag_stack_protect
== -1)
817 opts
->x_flag_stack_protect
= DEFAULT_FLAG_SSP
;
819 if (opts
->x_optimize
== 0)
821 /* Inlining does not work if not optimizing,
822 so force it not to be done. */
823 opts
->x_warn_inline
= 0;
824 opts
->x_flag_no_inline
= 1;
827 /* The optimization to partition hot and cold basic blocks into separate
828 sections of the .o and executable files does not work (currently)
829 with exception handling. This is because there is no support for
830 generating unwind info. If opts->x_flag_exceptions is turned on
831 we need to turn off the partitioning optimization. */
833 ui_except
= targetm_common
.except_unwind_info (opts
);
835 if (opts
->x_flag_exceptions
836 && opts
->x_flag_reorder_blocks_and_partition
837 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
839 if (opts_set
->x_flag_reorder_blocks_and_partition
)
841 "%<-freorder-blocks-and-partition%> does not work "
842 "with exceptions on this architecture");
843 opts
->x_flag_reorder_blocks_and_partition
= 0;
844 opts
->x_flag_reorder_blocks
= 1;
847 /* If user requested unwind info, then turn off the partitioning
850 if (opts
->x_flag_unwind_tables
851 && !targetm_common
.unwind_tables_default
852 && opts
->x_flag_reorder_blocks_and_partition
853 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
855 if (opts_set
->x_flag_reorder_blocks_and_partition
)
857 "%<-freorder-blocks-and-partition%> does not support "
858 "unwind info on this architecture");
859 opts
->x_flag_reorder_blocks_and_partition
= 0;
860 opts
->x_flag_reorder_blocks
= 1;
863 /* If the target requested unwind info, then turn off the partitioning
864 optimization with a different message. Likewise, if the target does not
865 support named sections. */
867 if (opts
->x_flag_reorder_blocks_and_partition
868 && (!targetm_common
.have_named_sections
869 || (opts
->x_flag_unwind_tables
870 && targetm_common
.unwind_tables_default
871 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
873 if (opts_set
->x_flag_reorder_blocks_and_partition
)
875 "%<-freorder-blocks-and-partition%> does not work "
876 "on this architecture");
877 opts
->x_flag_reorder_blocks_and_partition
= 0;
878 opts
->x_flag_reorder_blocks
= 1;
882 /* Pipelining of outer loops is only possible when general pipelining
883 capabilities are requested. */
884 if (!opts
->x_flag_sel_sched_pipelining
)
885 opts
->x_flag_sel_sched_pipelining_outer_loops
= 0;
887 if (opts
->x_flag_conserve_stack
)
889 maybe_set_param_value (PARAM_LARGE_STACK_FRAME
, 100,
890 opts
->x_param_values
, opts_set
->x_param_values
);
891 maybe_set_param_value (PARAM_STACK_FRAME_GROWTH
, 40,
892 opts
->x_param_values
, opts_set
->x_param_values
);
895 if (opts
->x_flag_lto
)
898 opts
->x_flag_generate_lto
= 1;
900 /* When generating IL, do not operate in whole-program mode.
901 Otherwise, symbols will be privatized too early, causing link
903 opts
->x_flag_whole_program
= 0;
905 error_at (loc
, "LTO support has not been enabled in this configuration");
907 if (!opts
->x_flag_fat_lto_objects
909 || (opts_set
->x_flag_use_linker_plugin
910 && !opts
->x_flag_use_linker_plugin
)))
912 if (opts_set
->x_flag_fat_lto_objects
)
913 error_at (loc
, "%<-fno-fat-lto-objects%> are supported only with "
915 opts
->x_flag_fat_lto_objects
= 1;
919 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
920 default value if they choose based on other options. */
921 if (opts
->x_flag_split_stack
== -1)
922 opts
->x_flag_split_stack
= 0;
923 else if (opts
->x_flag_split_stack
)
925 if (!targetm_common
.supports_split_stack (true, opts
))
927 error_at (loc
, "%<-fsplit-stack%> is not supported by "
928 "this compiler configuration");
929 opts
->x_flag_split_stack
= 0;
933 /* If stack splitting is turned on, and the user did not explicitly
934 request function partitioning, turn off partitioning, as it
935 confuses the linker when trying to handle partitioned split-stack
936 code that calls a non-split-stack functions. But if partitioning
937 was turned on explicitly just hope for the best. */
938 if (opts
->x_flag_split_stack
939 && opts
->x_flag_reorder_blocks_and_partition
940 && !opts_set
->x_flag_reorder_blocks_and_partition
)
941 opts
->x_flag_reorder_blocks_and_partition
= 0;
943 if (opts
->x_flag_reorder_blocks_and_partition
944 && !opts_set
->x_flag_reorder_functions
)
945 opts
->x_flag_reorder_functions
= 1;
947 /* Tune vectorization related parametees according to cost model. */
948 if (opts
->x_flag_vect_cost_model
== VECT_COST_MODEL_CHEAP
)
950 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS
,
951 6, opts
->x_param_values
, opts_set
->x_param_values
);
952 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS
,
953 0, opts
->x_param_values
, opts_set
->x_param_values
);
954 maybe_set_param_value (PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT
,
955 0, opts
->x_param_values
, opts_set
->x_param_values
);
958 /* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
960 if ((!opts
->x_flag_tree_loop_vectorize
&& !opts
->x_flag_tree_slp_vectorize
)
961 || !opts
->x_flag_tree_loop_if_convert
)
962 maybe_set_param_value (PARAM_MAX_STORES_TO_SINK
, 0,
963 opts
->x_param_values
, opts_set
->x_param_values
);
965 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
966 if (opts
->x_dwarf_split_debug_info
)
967 opts
->x_debug_generate_pub_sections
= 2;
969 if ((opts
->x_flag_sanitize
970 & (SANITIZE_USER_ADDRESS
| SANITIZE_KERNEL_ADDRESS
)) == 0)
972 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_COMPARE
)
974 "%<-fsanitize=pointer-compare%> must be combined with "
975 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
976 if (opts
->x_flag_sanitize
& SANITIZE_POINTER_SUBTRACT
)
978 "%<-fsanitize=pointer-subtract%> must be combined with "
979 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
982 /* Userspace and kernel ASan conflict with each other. */
983 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
984 && (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
))
986 "%<-fsanitize=address%> is incompatible with "
987 "%<-fsanitize=kernel-address%>");
990 if ((opts
->x_flag_sanitize
& SANITIZE_ADDRESS
)
991 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
993 "%<-fsanitize=address%> and %<-fsanitize=kernel-address%> "
994 "are incompatible with %<-fsanitize=thread%>");
996 if ((opts
->x_flag_sanitize
& SANITIZE_LEAK
)
997 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
999 "%<-fsanitize=leak%> is incompatible with %<-fsanitize=thread%>");
1001 /* Check error recovery for -fsanitize-recover option. */
1002 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1003 if ((opts
->x_flag_sanitize_recover
& sanitizer_opts
[i
].flag
)
1004 && !sanitizer_opts
[i
].can_recover
)
1005 error_at (loc
, "%<-fsanitize-recover=%s%> is not supported",
1006 sanitizer_opts
[i
].name
);
1008 /* When instrumenting the pointers, we don't want to remove
1009 the null pointer checks. */
1010 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
1011 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
1012 opts
->x_flag_delete_null_pointer_checks
= 0;
1014 /* Aggressive compiler optimizations may cause false negatives. */
1015 if (opts
->x_flag_sanitize
& ~(SANITIZE_LEAK
| SANITIZE_UNREACHABLE
))
1016 opts
->x_flag_aggressive_loop_optimizations
= 0;
1018 /* Enable -fsanitize-address-use-after-scope if address sanitizer is
1020 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
1021 && !opts_set
->x_flag_sanitize_address_use_after_scope
)
1022 opts
->x_flag_sanitize_address_use_after_scope
= true;
1024 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1026 if (opts
->x_flag_sanitize_address_use_after_scope
)
1028 if (opts
->x_flag_stack_reuse
!= SR_NONE
1029 && opts_set
->x_flag_stack_reuse
!= SR_NONE
)
1031 "%<-fsanitize-address-use-after-scope%> requires "
1032 "%<-fstack-reuse=none%> option");
1034 opts
->x_flag_stack_reuse
= SR_NONE
;
1037 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
) && opts
->x_flag_tm
)
1038 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1040 if ((opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) && opts
->x_flag_tm
)
1041 sorry ("transactional memory is not supported with "
1042 "%<-fsanitize=kernel-address%>");
1045 #define LEFT_COLUMN 27
1047 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1048 followed by word-wrapped HELP in a second column. */
1050 wrap_help (const char *help
,
1052 unsigned int item_width
,
1053 unsigned int columns
)
1055 unsigned int col_width
= LEFT_COLUMN
;
1056 unsigned int remaining
, room
, len
;
1058 remaining
= strlen (help
);
1062 room
= columns
- 3 - MAX (col_width
, item_width
);
1071 for (i
= 0; help
[i
]; i
++)
1073 if (i
>= room
&& len
!= remaining
)
1077 else if ((help
[i
] == '-' || help
[i
] == '/')
1078 && help
[i
+ 1] != ' '
1079 && i
> 0 && ISALPHA (help
[i
- 1]))
1084 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1086 while (help
[len
] == ' ')
1094 /* Data structure used to print list of valid option values. */
1096 struct option_help_tuple
1098 option_help_tuple (int code
, vec
<const char *> values
):
1099 m_code (code
), m_values (values
)
1102 /* Code of an option. */
1105 /* List of possible values. */
1106 vec
<const char *> m_values
;
1109 /* Print help for a specific front-end, etc. */
1111 print_filtered_help (unsigned int include_flags
,
1112 unsigned int exclude_flags
,
1113 unsigned int any_flags
,
1114 unsigned int columns
,
1115 struct gcc_options
*opts
,
1116 unsigned int lang_mask
)
1121 bool displayed
= false;
1124 if (include_flags
== CL_PARAMS
)
1126 for (i
= 0; i
< LAST_PARAM
; i
++)
1128 const char *param
= compiler_params
[i
].option
;
1130 help
= compiler_params
[i
].help
;
1131 if (help
== NULL
|| *help
== '\0')
1133 if (exclude_flags
& CL_UNDOCUMENTED
)
1135 help
= undocumented_msg
;
1138 /* Get the translation. */
1141 if (!opts
->x_quiet_flag
)
1143 snprintf (new_help
, sizeof (new_help
),
1144 _("default %d minimum %d maximum %d"),
1145 compiler_params
[i
].default_value
,
1146 compiler_params
[i
].min_value
,
1147 compiler_params
[i
].max_value
);
1150 wrap_help (help
, param
, strlen (param
), columns
);
1156 if (!opts
->x_help_printed
)
1157 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1159 if (!opts
->x_help_enum_printed
)
1160 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1162 auto_vec
<option_help_tuple
> help_tuples
;
1164 for (i
= 0; i
< cl_options_count
; i
++)
1166 const struct cl_option
*option
= cl_options
+ i
;
1171 if (include_flags
== 0
1172 || ((option
->flags
& include_flags
) != include_flags
))
1174 if ((option
->flags
& any_flags
) == 0)
1178 /* Skip unwanted switches. */
1179 if ((option
->flags
& exclude_flags
) != 0)
1182 /* The driver currently prints its own help text. */
1183 if ((option
->flags
& CL_DRIVER
) != 0
1184 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1185 | CL_COMMON
| CL_TARGET
)) == 0)
1189 /* Skip switches that have already been printed. */
1190 if (opts
->x_help_printed
[i
])
1193 opts
->x_help_printed
[i
] = true;
1195 help
= option
->help
;
1198 if (exclude_flags
& CL_UNDOCUMENTED
)
1201 help
= undocumented_msg
;
1204 if (option
->alias_target
< N_OPTS
1205 && cl_options
[option
->alias_target
].help
)
1207 if (help
== undocumented_msg
)
1209 /* For undocumented options that are aliases for other options
1210 that are documented, point the reader to the other option in
1211 preference of the former. */
1212 snprintf (new_help
, sizeof new_help
,
1213 _("Same as %s. Use the latter option instead."),
1214 cl_options
[option
->alias_target
].opt_text
);
1218 /* For documented options with aliases, mention the aliased
1219 option's name for reference. */
1220 snprintf (new_help
, sizeof new_help
,
1221 _("%s Same as %s."),
1222 help
, cl_options
[option
->alias_target
].opt_text
);
1228 if (option
->warn_message
)
1230 /* Mention that the use of the option will trigger a warning. */
1231 if (help
== new_help
)
1232 snprintf (new_help
+ strlen (new_help
),
1233 sizeof new_help
- strlen (new_help
),
1234 " %s", _(use_diagnosed_msg
));
1236 snprintf (new_help
, sizeof new_help
,
1237 "%s %s", help
, _(use_diagnosed_msg
));
1242 /* Get the translation. */
1245 /* Find the gap between the name of the
1246 option and its descriptive text. */
1247 tab
= strchr (help
, '\t');
1256 opt
= option
->opt_text
;
1260 /* With the -Q option enabled we change the descriptive text associated
1261 with an option to be an indication of its current setting. */
1262 if (!opts
->x_quiet_flag
)
1264 void *flag_var
= option_flag_var (i
, opts
);
1266 if (len
< (LEFT_COLUMN
+ 2))
1267 strcpy (new_help
, "\t\t");
1269 strcpy (new_help
, "\t");
1271 if (flag_var
!= NULL
1272 && option
->var_type
!= CLVC_DEFER
)
1274 if (option
->flags
& CL_JOINED
)
1276 if (option
->var_type
== CLVC_STRING
)
1278 if (* (const char **) flag_var
!= NULL
)
1279 snprintf (new_help
+ strlen (new_help
),
1280 sizeof (new_help
) - strlen (new_help
),
1281 "%s", * (const char **) flag_var
);
1283 else if (option
->var_type
== CLVC_ENUM
)
1285 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1287 const char *arg
= NULL
;
1289 value
= e
->get (flag_var
);
1290 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1292 arg
= _("[default]");
1293 snprintf (new_help
+ strlen (new_help
),
1294 sizeof (new_help
) - strlen (new_help
),
1298 sprintf (new_help
+ strlen (new_help
),
1299 "%d", * (int *) flag_var
);
1302 strcat (new_help
, option_enabled (i
, opts
)
1303 ? _("[enabled]") : _("[disabled]"));
1309 if (option
->range_max
!= -1)
1312 snprintf (b
, sizeof (b
), "<%d,%d>", option
->range_min
,
1314 opt
= concat (opt
, b
, NULL
);
1318 wrap_help (help
, opt
, len
, columns
);
1321 if (option
->var_type
== CLVC_ENUM
1322 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1323 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1326 vec
<const char *> option_values
1327 = targetm_common
.get_valid_option_values (i
, NULL
);
1328 if (!option_values
.is_empty ())
1329 help_tuples
.safe_push (option_help_tuple (i
, option_values
));
1335 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1338 printf (_(" No options with the desired characteristics were found\n"));
1343 /* PR 31349: Tell the user how to see all of the
1344 options supported by a specific front end. */
1345 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1346 if ((1U << i
) & langs
)
1347 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1348 lang_names
[i
], lang_names
[i
]);
1352 else if (! displayed
)
1353 printf (_(" All options with the desired characteristics have already been displayed\n"));
1357 /* Print details of enumerated option arguments, if those
1358 enumerations have help text headings provided. If no help text
1359 is provided, presume that the possible values are listed in the
1360 help text for the relevant options. */
1361 for (i
= 0; i
< cl_enums_count
; i
++)
1363 unsigned int j
, pos
;
1365 if (opts
->x_help_enum_printed
[i
] != 1)
1367 if (cl_enums
[i
].help
== NULL
)
1369 printf (" %s\n ", _(cl_enums
[i
].help
));
1371 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1373 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1375 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1377 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1387 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1392 opts
->x_help_enum_printed
[i
] = 2;
1395 for (unsigned i
= 0; i
< help_tuples
.length (); i
++)
1397 const struct cl_option
*option
= cl_options
+ help_tuples
[i
].m_code
;
1398 printf (" Known valid arguments for %s option:\n ", option
->opt_text
);
1399 for (unsigned j
= 0; j
< help_tuples
[i
].m_values
.length (); j
++)
1400 printf (" %s", help_tuples
[i
].m_values
[j
]);
1405 /* Display help for a specified type of option.
1406 The options must have ALL of the INCLUDE_FLAGS set
1407 ANY of the flags in the ANY_FLAGS set
1408 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1409 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1411 print_specific_help (unsigned int include_flags
,
1412 unsigned int exclude_flags
,
1413 unsigned int any_flags
,
1414 struct gcc_options
*opts
,
1415 unsigned int lang_mask
)
1417 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1418 const char * description
= NULL
;
1419 const char * descrip_extra
= "";
1423 /* Sanity check: Make sure that we do not have more
1424 languages than we have bits available to enumerate them. */
1425 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1427 /* If we have not done so already, obtain
1428 the desired maximum width of the output. */
1429 if (opts
->x_help_columns
== 0)
1431 opts
->x_help_columns
= get_terminal_width ();
1432 if (opts
->x_help_columns
== INT_MAX
)
1433 /* Use a reasonable default. */
1434 opts
->x_help_columns
= 80;
1437 /* Decide upon the title for the options that we are going to display. */
1438 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1440 switch (flag
& include_flags
)
1447 description
= _("The following options are target specific");
1450 description
= _("The following options control compiler warning messages");
1452 case CL_OPTIMIZATION
:
1453 description
= _("The following options control optimizations");
1456 description
= _("The following options are language-independent");
1459 description
= _("The --param option recognizes the following as parameters");
1462 if (i
>= cl_lang_count
)
1464 if (exclude_flags
& all_langs_mask
)
1465 description
= _("The following options are specific to just the language ");
1467 description
= _("The following options are supported by the language ");
1468 descrip_extra
= lang_names
[i
];
1473 if (description
== NULL
)
1477 if (include_flags
& CL_UNDOCUMENTED
)
1478 description
= _("The following options are not documented");
1479 else if (include_flags
& CL_SEPARATE
)
1480 description
= _("The following options take separate arguments");
1481 else if (include_flags
& CL_JOINED
)
1482 description
= _("The following options take joined arguments");
1485 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1492 if (any_flags
& all_langs_mask
)
1493 description
= _("The following options are language-related");
1495 description
= _("The following options are language-independent");
1499 printf ("%s%s:\n", description
, descrip_extra
);
1500 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
1501 opts
->x_help_columns
, opts
, lang_mask
);
1504 /* Enable FDO-related flags. */
1507 enable_fdo_optimizations (struct gcc_options
*opts
,
1508 struct gcc_options
*opts_set
,
1511 if (!opts_set
->x_flag_branch_probabilities
)
1512 opts
->x_flag_branch_probabilities
= value
;
1513 if (!opts_set
->x_flag_profile_values
)
1514 opts
->x_flag_profile_values
= value
;
1515 if (!opts_set
->x_flag_unroll_loops
)
1516 opts
->x_flag_unroll_loops
= value
;
1517 if (!opts_set
->x_flag_peel_loops
)
1518 opts
->x_flag_peel_loops
= value
;
1519 if (!opts_set
->x_flag_tracer
)
1520 opts
->x_flag_tracer
= value
;
1521 if (!opts_set
->x_flag_value_profile_transformations
)
1522 opts
->x_flag_value_profile_transformations
= value
;
1523 if (!opts_set
->x_flag_inline_functions
)
1524 opts
->x_flag_inline_functions
= value
;
1525 if (!opts_set
->x_flag_ipa_cp
)
1526 opts
->x_flag_ipa_cp
= value
;
1527 if (!opts_set
->x_flag_ipa_cp_clone
1528 && value
&& opts
->x_flag_ipa_cp
)
1529 opts
->x_flag_ipa_cp_clone
= value
;
1530 if (!opts_set
->x_flag_ipa_bit_cp
1531 && value
&& opts
->x_flag_ipa_cp
)
1532 opts
->x_flag_ipa_bit_cp
= value
;
1533 if (!opts_set
->x_flag_predictive_commoning
)
1534 opts
->x_flag_predictive_commoning
= value
;
1535 if (!opts_set
->x_flag_split_loops
)
1536 opts
->x_flag_split_loops
= value
;
1537 if (!opts_set
->x_flag_unswitch_loops
)
1538 opts
->x_flag_unswitch_loops
= value
;
1539 if (!opts_set
->x_flag_gcse_after_reload
)
1540 opts
->x_flag_gcse_after_reload
= value
;
1541 if (!opts_set
->x_flag_tree_loop_vectorize
)
1542 opts
->x_flag_tree_loop_vectorize
= value
;
1543 if (!opts_set
->x_flag_tree_slp_vectorize
)
1544 opts
->x_flag_tree_slp_vectorize
= value
;
1545 if (!opts_set
->x_flag_vect_cost_model
)
1546 opts
->x_flag_vect_cost_model
= VECT_COST_MODEL_DYNAMIC
;
1547 if (!opts_set
->x_flag_tree_loop_distribute_patterns
)
1548 opts
->x_flag_tree_loop_distribute_patterns
= value
;
1551 /* -f{,no-}sanitize{,-recover}= suboptions. */
1552 const struct sanitizer_opts_s sanitizer_opts
[] =
1554 #define SANITIZER_OPT(name, flags, recover) \
1555 { #name, flags, sizeof #name - 1, recover }
1556 SANITIZER_OPT (address
, (SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
), true),
1557 SANITIZER_OPT (kernel
-address
, (SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
1559 SANITIZER_OPT (pointer
-compare
, SANITIZE_POINTER_COMPARE
, true),
1560 SANITIZER_OPT (pointer
-subtract
, SANITIZE_POINTER_SUBTRACT
, true),
1561 SANITIZER_OPT (thread
, SANITIZE_THREAD
, false),
1562 SANITIZER_OPT (leak
, SANITIZE_LEAK
, false),
1563 SANITIZER_OPT (shift
, SANITIZE_SHIFT
, true),
1564 SANITIZER_OPT (shift
-base
, SANITIZE_SHIFT_BASE
, true),
1565 SANITIZER_OPT (shift
-exponent
, SANITIZE_SHIFT_EXPONENT
, true),
1566 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
, true),
1567 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
, true),
1568 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
, false),
1569 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
, true),
1570 SANITIZER_OPT (return, SANITIZE_RETURN
, false),
1571 SANITIZER_OPT (null
, SANITIZE_NULL
, true),
1572 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
, true),
1573 SANITIZER_OPT (bool, SANITIZE_BOOL
, true),
1574 SANITIZER_OPT (enum, SANITIZE_ENUM
, true),
1575 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
, true),
1576 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
, true),
1577 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
, true),
1578 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
, true),
1579 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
, true),
1580 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
, true),
1581 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
,
1583 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
, true),
1584 SANITIZER_OPT (vptr
, SANITIZE_VPTR
, true),
1585 SANITIZER_OPT (pointer
-overflow
, SANITIZE_POINTER_OVERFLOW
, true),
1586 SANITIZER_OPT (builtin
, SANITIZE_BUILTIN
, true),
1587 SANITIZER_OPT (all
, ~0U, true),
1588 #undef SANITIZER_OPT
1589 { NULL
, 0U, 0UL, false }
1592 /* -f{,no-}sanitize-coverage= suboptions. */
1593 const struct sanitizer_opts_s coverage_sanitizer_opts
[] =
1595 #define COVERAGE_SANITIZER_OPT(name, flags) \
1596 { #name, flags, sizeof #name - 1, true }
1597 COVERAGE_SANITIZER_OPT (trace
-pc
, SANITIZE_COV_TRACE_PC
),
1598 COVERAGE_SANITIZER_OPT (trace
-cmp
, SANITIZE_COV_TRACE_CMP
),
1599 #undef COVERAGE_SANITIZER_OPT
1600 { NULL
, 0U, 0UL, false }
1603 /* A struct for describing a run of chars within a string. */
1605 struct string_fragment
1607 string_fragment (const char *start
, size_t len
)
1608 : m_start (start
), m_len (len
) {}
1610 const char *m_start
;
1614 /* Specialization of edit_distance_traits for string_fragment,
1615 for use by get_closest_sanitizer_option. */
1618 struct edit_distance_traits
<const string_fragment
&>
1620 static size_t get_length (const string_fragment
&fragment
)
1622 return fragment
.m_len
;
1625 static const char *get_string (const string_fragment
&fragment
)
1627 return fragment
.m_start
;
1631 /* Given ARG, an unrecognized sanitizer option, return the best
1632 matching sanitizer option, or NULL if there isn't one.
1633 OPTS is array of candidate sanitizer options.
1634 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or
1635 OPT_fsanitize_coverage_.
1636 VALUE is non-zero for the regular form of the option, zero
1637 for the "no-" form (e.g. "-fno-sanitize-recover="). */
1640 get_closest_sanitizer_option (const string_fragment
&arg
,
1641 const struct sanitizer_opts_s
*opts
,
1642 enum opt_code code
, int value
)
1644 best_match
<const string_fragment
&, const char*> bm (arg
);
1645 for (int i
= 0; opts
[i
].name
!= NULL
; ++i
)
1647 /* -fsanitize=all is not valid, so don't offer it. */
1648 if (code
== OPT_fsanitize_
1649 && opts
[i
].flag
== ~0U
1653 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
1654 don't offer the non-recoverable options. */
1655 if (code
== OPT_fsanitize_recover_
1656 && !opts
[i
].can_recover
1660 bm
.consider (opts
[i
].name
);
1662 return bm
.get_best_meaningful_candidate ();
1665 /* Parse comma separated sanitizer suboptions from P for option SCODE,
1666 adjust previous FLAGS and return new ones. If COMPLAIN is false,
1667 don't issue diagnostics. */
1670 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
1671 unsigned int flags
, int value
, bool complain
)
1673 enum opt_code code
= (enum opt_code
) scode
;
1675 const struct sanitizer_opts_s
*opts
;
1676 if (code
== OPT_fsanitize_coverage_
)
1677 opts
= coverage_sanitizer_opts
;
1679 opts
= sanitizer_opts
;
1685 const char *comma
= strchr (p
, ',');
1697 /* Check to see if the string matches an option class name. */
1698 for (i
= 0; opts
[i
].name
!= NULL
; ++i
)
1699 if (len
== opts
[i
].len
&& memcmp (p
, opts
[i
].name
, len
) == 0)
1701 /* Handle both -fsanitize and -fno-sanitize cases. */
1702 if (value
&& opts
[i
].flag
== ~0U)
1704 if (code
== OPT_fsanitize_
)
1707 error_at (loc
, "%<-fsanitize=all%> option is not valid");
1710 flags
|= ~(SANITIZE_THREAD
| SANITIZE_LEAK
1711 | SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
1715 /* Do not enable -fsanitize-recover=unreachable and
1716 -fsanitize-recover=return if -fsanitize-recover=undefined
1718 if (code
== OPT_fsanitize_recover_
1719 && opts
[i
].flag
== SANITIZE_UNDEFINED
)
1720 flags
|= (SANITIZE_UNDEFINED
1721 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
));
1723 flags
|= opts
[i
].flag
;
1726 flags
&= ~opts
[i
].flag
;
1731 if (! found
&& complain
)
1734 = get_closest_sanitizer_option (string_fragment (p
, len
),
1738 if (code
== OPT_fsanitize_recover_
)
1739 suffix
= "-recover";
1740 else if (code
== OPT_fsanitize_coverage_
)
1741 suffix
= "-coverage";
1747 "unrecognized argument to -f%ssanitize%s= option: %q.*s;"
1748 " did you mean %qs?",
1750 suffix
, (int) len
, p
, hint
);
1753 "unrecognized argument to -f%ssanitize%s= option: %q.*s",
1755 suffix
, (int) len
, p
);
1765 /* Parse string values of no_sanitize attribute passed in VALUE.
1766 Values are separated with comma. */
1769 parse_no_sanitize_attribute (char *value
)
1771 unsigned int flags
= 0;
1773 char *q
= strtok (value
, ",");
1777 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1778 if (strcmp (sanitizer_opts
[i
].name
, q
) == 0)
1780 flags
|= sanitizer_opts
[i
].flag
;
1781 if (sanitizer_opts
[i
].flag
== SANITIZE_UNDEFINED
)
1782 flags
|= SANITIZE_UNDEFINED_NONDEFAULT
;
1786 if (sanitizer_opts
[i
].name
== NULL
)
1787 warning (OPT_Wattributes
,
1788 "%<%s%> attribute directive ignored", q
);
1790 q
= strtok (NULL
, ",");
1796 /* Parse -falign-NAME format for a FLAG value. Return individual
1797 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
1798 set, print error message at LOC location. */
1801 parse_and_check_align_values (const char *flag
,
1803 auto_vec
<unsigned> &result_values
,
1807 char *str
= xstrdup (flag
);
1808 for (char *p
= strtok (str
, ":"); p
; p
= strtok (NULL
, ":"))
1811 int v
= strtol (p
, &end
, 10);
1812 if (*end
!= '\0' || v
< 0)
1815 error_at (loc
, "invalid arguments for %<-falign-%s%> option: %qs",
1821 result_values
.safe_push ((unsigned)v
);
1826 /* Check that we have a correct number of values. */
1828 unsigned max_valid_values
= 4;
1830 unsigned max_valid_values
= 2;
1833 if (result_values
.is_empty ()
1834 || result_values
.length () > max_valid_values
)
1837 error_at (loc
, "invalid number of arguments for %<-falign-%s%> "
1838 "option: %qs", name
, flag
);
1842 for (unsigned i
= 0; i
< result_values
.length (); i
++)
1843 if (result_values
[i
] > MAX_CODE_ALIGN_VALUE
)
1846 error_at (loc
, "%<-falign-%s%> is not between 0 and %d",
1847 name
, MAX_CODE_ALIGN_VALUE
);
1854 /* Check that alignment value FLAG for -falign-NAME is valid at a given
1858 check_alignment_argument (location_t loc
, const char *flag
, const char *name
)
1860 auto_vec
<unsigned> align_result
;
1861 parse_and_check_align_values (flag
, name
, align_result
, true, loc
);
1864 /* Handle target- and language-independent options. Return zero to
1865 generate an "unknown option" message. Only options that need
1866 extra handling need to be listed here; if you simply want
1867 DECODED->value assigned to a variable, it happens automatically. */
1870 common_handle_option (struct gcc_options
*opts
,
1871 struct gcc_options
*opts_set
,
1872 const struct cl_decoded_option
*decoded
,
1873 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
1875 const struct cl_option_handlers
*handlers
,
1876 diagnostic_context
*dc
,
1877 void (*target_option_override_hook
) (void))
1879 size_t scode
= decoded
->opt_index
;
1880 const char *arg
= decoded
->arg
;
1881 HOST_WIDE_INT value
= decoded
->value
;
1882 enum opt_code code
= (enum opt_code
) scode
;
1884 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
1889 handle_param (opts
, opts_set
, loc
, arg
);
1894 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1895 unsigned int undoc_mask
;
1898 if (lang_mask
== CL_DRIVER
)
1901 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
1904 target_option_override_hook ();
1905 /* First display any single language specific options. */
1906 for (i
= 0; i
< cl_lang_count
; i
++)
1908 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
1910 /* Next display any multi language specific options. */
1911 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
1912 /* Then display any remaining, non-language options. */
1913 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
1915 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
1916 opts
->x_exit_after_options
= true;
1920 case OPT__target_help
:
1921 if (lang_mask
== CL_DRIVER
)
1924 target_option_override_hook ();
1925 print_specific_help (CL_TARGET
, CL_UNDOCUMENTED
, 0, opts
, lang_mask
);
1926 opts
->x_exit_after_options
= true;
1931 const char *a
= arg
;
1932 unsigned int include_flags
= 0;
1933 /* Note - by default we include undocumented options when listing
1934 specific classes. If you only want to see documented options
1935 then add ",^undocumented" to the --help= option. E.g.:
1937 --help=target,^undocumented */
1938 unsigned int exclude_flags
= 0;
1940 if (lang_mask
== CL_DRIVER
)
1943 /* Walk along the argument string, parsing each word in turn.
1945 arg = [^]{word}[,{arg}]
1946 word = {optimizers|target|warnings|undocumented|
1947 params|common|<language>} */
1957 { "optimizers", CL_OPTIMIZATION
},
1958 { "target", CL_TARGET
},
1959 { "warnings", CL_WARNING
},
1960 { "undocumented", CL_UNDOCUMENTED
},
1961 { "params", CL_PARAMS
},
1962 { "joined", CL_JOINED
},
1963 { "separate", CL_SEPARATE
},
1964 { "common", CL_COMMON
},
1967 unsigned int *pflags
;
1969 unsigned int lang_flag
, specific_flag
;
1978 error_at (loc
, "missing argument to %qs", "--help=^");
1981 pflags
= &exclude_flags
;
1984 pflags
= &include_flags
;
1986 comma
= strchr (a
, ',');
1997 /* Check to see if the string matches an option class name. */
1998 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
1999 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
2001 specific_flag
= specifics
[i
].flag
;
2005 /* Check to see if the string matches a language name.
2006 Note - we rely upon the alpha-sorted nature of the entries in
2007 the lang_names array, specifically that shorter names appear
2008 before their longer variants. (i.e. C before C++). That way
2009 when we are attempting to match --help=c for example we will
2010 match with C first and not C++. */
2011 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
2012 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
2014 lang_flag
= 1U << i
;
2018 if (specific_flag
!= 0)
2021 *pflags
|= specific_flag
;
2024 /* The option's argument matches both the start of a
2025 language name and the start of an option class name.
2026 We have a special case for when the user has
2027 specified "--help=c", but otherwise we have to issue
2029 if (strncasecmp (a
, "c", len
) == 0)
2030 *pflags
|= lang_flag
;
2033 "--help argument %q.*s is ambiguous, "
2034 "please be more specific",
2038 else if (lang_flag
!= 0)
2039 *pflags
|= lang_flag
;
2042 "unrecognized argument to --help= option: %q.*s",
2052 target_option_override_hook ();
2053 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
2056 opts
->x_exit_after_options
= true;
2061 if (lang_mask
== CL_DRIVER
)
2064 opts
->x_exit_after_options
= true;
2067 case OPT__completion_
:
2070 case OPT_fsanitize_
:
2071 opts
->x_flag_sanitize
2072 = parse_sanitizer_options (arg
, loc
, code
,
2073 opts
->x_flag_sanitize
, value
, true);
2075 /* Kernel ASan implies normal ASan but does not yet support
2077 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
2079 maybe_set_param_value (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD
,
2080 0, opts
->x_param_values
,
2081 opts_set
->x_param_values
);
2082 maybe_set_param_value (PARAM_ASAN_GLOBALS
, 0, opts
->x_param_values
,
2083 opts_set
->x_param_values
);
2084 maybe_set_param_value (PARAM_ASAN_STACK
, 0, opts
->x_param_values
,
2085 opts_set
->x_param_values
);
2086 maybe_set_param_value (PARAM_ASAN_PROTECT_ALLOCAS
, 0,
2087 opts
->x_param_values
,
2088 opts_set
->x_param_values
);
2089 maybe_set_param_value (PARAM_ASAN_USE_AFTER_RETURN
, 0,
2090 opts
->x_param_values
,
2091 opts_set
->x_param_values
);
2095 case OPT_fsanitize_recover_
:
2096 opts
->x_flag_sanitize_recover
2097 = parse_sanitizer_options (arg
, loc
, code
,
2098 opts
->x_flag_sanitize_recover
, value
, true);
2101 case OPT_fasan_shadow_offset_
:
2105 case OPT_fsanitize_address_use_after_scope
:
2106 opts
->x_flag_sanitize_address_use_after_scope
= value
;
2109 case OPT_fsanitize_recover
:
2111 opts
->x_flag_sanitize_recover
2112 |= (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)
2113 & ~(SANITIZE_UNREACHABLE
| SANITIZE_RETURN
);
2115 opts
->x_flag_sanitize_recover
2116 &= ~(SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
);
2119 case OPT_fsanitize_coverage_
:
2120 opts
->x_flag_sanitize_coverage
2121 = parse_sanitizer_options (arg
, loc
, code
,
2122 opts
->x_flag_sanitize_coverage
, value
, true);
2129 /* Currently handled in a prescan. */
2133 dc
->warning_as_error_requested
= value
;
2137 if (lang_mask
== CL_DRIVER
)
2140 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
2141 opts
, opts_set
, loc
, dc
);
2144 case OPT_Wfatal_errors
:
2145 dc
->fatal_errors
= value
;
2148 case OPT_Wstack_usage_
:
2149 opts
->x_flag_stack_usage_info
= value
!= -1;
2152 case OPT_Wstrict_aliasing
:
2153 set_Wstrict_aliasing (opts
, value
);
2156 case OPT_Wstrict_overflow
:
2157 opts
->x_warn_strict_overflow
= (value
2158 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2162 case OPT_Wsystem_headers
:
2163 dc
->dc_warn_system_headers
= value
;
2167 opts
->x_flag_gen_aux_info
= 1;
2170 case OPT_auxbase_strip
:
2172 char *tmp
= xstrdup (arg
);
2173 strip_off_ending (tmp
, strlen (tmp
));
2175 opts
->x_aux_base_name
= tmp
;
2182 decode_d_option (arg
, opts
, loc
, dc
);
2185 case OPT_fcall_used_
:
2186 case OPT_fcall_saved_
:
2194 case OPT_fdbg_cnt_list
:
2196 opts
->x_exit_after_options
= true;
2199 case OPT_fdebug_prefix_map_
:
2200 case OPT_ffile_prefix_map_
:
2204 case OPT_fdiagnostics_show_location_
:
2205 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
2208 case OPT_fdiagnostics_show_caret
:
2209 dc
->show_caret
= value
;
2212 case OPT_fdiagnostics_show_labels
:
2213 dc
->show_labels_p
= value
;
2216 case OPT_fdiagnostics_show_line_numbers
:
2217 dc
->show_line_numbers_p
= value
;
2220 case OPT_fdiagnostics_color_
:
2221 diagnostic_color_init (dc
, value
);
2224 case OPT_fdiagnostics_parseable_fixits
:
2225 dc
->parseable_fixits_p
= value
;
2228 case OPT_fdiagnostics_show_option
:
2229 dc
->show_option_requested
= value
;
2232 case OPT_fdiagnostics_minimum_margin_width_
:
2233 dc
->min_margin_width
= value
;
2240 case OPT_ffast_math
:
2241 set_fast_math_flags (opts
, value
);
2244 case OPT_funsafe_math_optimizations
:
2245 set_unsafe_math_optimizations_flags (opts
, value
);
2252 case OPT_finline_limit_
:
2253 set_param_value ("max-inline-insns-single", value
/ 2,
2254 opts
->x_param_values
, opts_set
->x_param_values
);
2255 set_param_value ("max-inline-insns-auto", value
/ 2,
2256 opts
->x_param_values
, opts_set
->x_param_values
);
2259 case OPT_finstrument_functions_exclude_function_list_
:
2260 add_comma_separated_to_vector
2261 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
2264 case OPT_finstrument_functions_exclude_file_list_
:
2265 add_comma_separated_to_vector
2266 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
2269 case OPT_fmessage_length_
:
2270 pp_set_line_maximum_length (dc
->printer
, value
);
2271 diagnostic_set_caret_max_width (dc
, value
);
2275 case OPT_fopt_info_
:
2281 const char *p
= arg
;
2282 opts
->x_flag_disable_hsa
= true;
2285 const char *comma
= strchr (p
, ',');
2287 if ((strncmp (p
, "disable", 7) == 0)
2288 && (p
[7] == ',' || p
[7] == '\0'))
2290 opts
->x_flag_disable_hsa
= true;
2294 if ((strncmp (p
, "hsa", 3) == 0)
2295 && (p
[3] == ',' || p
[3] == '\0'))
2298 opts
->x_flag_disable_hsa
= false;
2300 sorry ("HSA has not been enabled during configuration");
2310 #ifndef ACCEL_COMPILER
2311 case OPT_foffload_abi_
:
2312 error_at (loc
, "%<-foffload-abi%> option can be specified only for "
2313 "offload compiler");
2317 case OPT_fpack_struct_
:
2318 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
2320 "structure alignment must be a small power of two, not %wu",
2323 opts
->x_initial_max_fld_align
= value
;
2327 case OPT_fplugin_arg_
:
2331 case OPT_fprofile_use_
:
2332 opts
->x_profile_data_prefix
= xstrdup (arg
);
2333 opts
->x_flag_profile_use
= true;
2335 /* No break here - do -fprofile-use processing. */
2337 case OPT_fprofile_use
:
2338 enable_fdo_optimizations (opts
, opts_set
, value
);
2339 if (!opts_set
->x_flag_profile_reorder_functions
)
2340 opts
->x_flag_profile_reorder_functions
= value
;
2341 /* Indirect call profiling should do all useful transformations
2342 speculative devirtualization does. */
2343 if (!opts_set
->x_flag_devirtualize_speculatively
2344 && opts
->x_flag_value_profile_transformations
)
2345 opts
->x_flag_devirtualize_speculatively
= false;
2348 case OPT_fauto_profile_
:
2349 opts
->x_auto_profile_file
= xstrdup (arg
);
2350 opts
->x_flag_auto_profile
= true;
2352 /* No break here - do -fauto-profile processing. */
2354 case OPT_fauto_profile
:
2355 enable_fdo_optimizations (opts
, opts_set
, value
);
2356 if (!opts_set
->x_flag_profile_correction
)
2357 opts
->x_flag_profile_correction
= value
;
2358 maybe_set_param_value (
2359 PARAM_EARLY_INLINER_MAX_ITERATIONS
, 10,
2360 opts
->x_param_values
, opts_set
->x_param_values
);
2363 case OPT_fprofile_generate_
:
2364 opts
->x_profile_data_prefix
= xstrdup (arg
);
2366 /* No break here - do -fprofile-generate processing. */
2368 case OPT_fprofile_generate
:
2369 if (!opts_set
->x_profile_arc_flag
)
2370 opts
->x_profile_arc_flag
= value
;
2371 if (!opts_set
->x_flag_profile_values
)
2372 opts
->x_flag_profile_values
= value
;
2373 if (!opts_set
->x_flag_inline_functions
)
2374 opts
->x_flag_inline_functions
= value
;
2375 if (!opts_set
->x_flag_ipa_bit_cp
)
2376 opts
->x_flag_ipa_bit_cp
= value
;
2377 /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
2378 quadratic. Disable the pass until better memory representation
2380 if (!opts_set
->x_flag_ipa_reference
)
2381 opts
->x_flag_ipa_reference
= false;
2384 case OPT_fpatchable_function_entry_
:
2386 char *patch_area_arg
= xstrdup (arg
);
2387 char *comma
= strchr (patch_area_arg
, ',');
2391 function_entry_patch_area_size
=
2392 integral_argument (patch_area_arg
);
2393 function_entry_patch_area_start
=
2394 integral_argument (comma
+ 1);
2398 function_entry_patch_area_size
=
2399 integral_argument (patch_area_arg
);
2400 function_entry_patch_area_start
= 0;
2402 if (function_entry_patch_area_size
< 0
2403 || function_entry_patch_area_start
< 0
2404 || function_entry_patch_area_size
2405 < function_entry_patch_area_start
)
2406 error ("invalid arguments for %<-fpatchable_function_entry%>");
2407 free (patch_area_arg
);
2411 case OPT_ftree_vectorize
:
2412 /* Automatically sets -ftree-loop-vectorize and
2413 -ftree-slp-vectorize. Nothing more to do here. */
2415 case OPT_fshow_column
:
2416 dc
->show_column
= value
;
2419 case OPT_frandom_seed
:
2420 /* The real switch is -fno-random-seed. */
2426 case OPT_frandom_seed_
:
2430 case OPT_fsched_verbose_
:
2431 #ifdef INSN_SCHEDULING
2432 /* Handled with Var in common.opt. */
2438 case OPT_fsched_stalled_insns_
:
2439 opts
->x_flag_sched_stalled_insns
= value
;
2440 if (opts
->x_flag_sched_stalled_insns
== 0)
2441 opts
->x_flag_sched_stalled_insns
= -1;
2444 case OPT_fsched_stalled_insns_dep_
:
2445 opts
->x_flag_sched_stalled_insns_dep
= value
;
2448 case OPT_fstack_check_
:
2449 if (!strcmp (arg
, "no"))
2450 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
2451 else if (!strcmp (arg
, "generic"))
2452 /* This is the old stack checking method. */
2453 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2454 ? FULL_BUILTIN_STACK_CHECK
2455 : GENERIC_STACK_CHECK
;
2456 else if (!strcmp (arg
, "specific"))
2457 /* This is the new stack checking method. */
2458 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2459 ? FULL_BUILTIN_STACK_CHECK
2460 : STACK_CHECK_STATIC_BUILTIN
2461 ? STATIC_BUILTIN_STACK_CHECK
2462 : GENERIC_STACK_CHECK
;
2464 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
2467 case OPT_fstack_limit
:
2468 /* The real switch is -fno-stack-limit. */
2474 case OPT_fstack_limit_register_
:
2475 case OPT_fstack_limit_symbol_
:
2479 case OPT_fstack_usage
:
2480 opts
->x_flag_stack_usage
= value
;
2481 opts
->x_flag_stack_usage_info
= value
!= 0;
2485 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
2490 if (arg
&& strlen (arg
) != 0)
2492 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
2493 "use %<-gdwarf-%s%> for DWARF version "
2494 "or %<-gdwarf -g%s%> for debug level", arg
, arg
, arg
);
2498 value
= opts
->x_dwarf_version
;
2502 if (value
< 2 || value
> 5)
2503 error_at (loc
, "dwarf version %wu is not supported", value
);
2505 opts
->x_dwarf_version
= value
;
2506 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
2509 case OPT_gsplit_dwarf
:
2510 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, "", opts
, opts_set
,
2515 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
2520 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
, opts
, opts_set
,
2525 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2530 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
, opts
, opts_set
,
2536 /* Handled completely via specs. */
2539 case OPT_pedantic_errors
:
2540 dc
->pedantic_errors
= 1;
2541 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
2543 handlers
, opts
, opts_set
,
2548 opts
->x_flag_lto
= value
? "" : NULL
;
2552 dc
->dc_inhibit_warnings
= true;
2555 case OPT_fmax_errors_
:
2556 dc
->max_errors
= value
;
2559 case OPT_fuse_ld_bfd
:
2560 case OPT_fuse_ld_gold
:
2561 case OPT_fuse_ld_lld
:
2562 case OPT_fuse_linker_plugin
:
2563 /* No-op. Used by the driver and passed to us because it starts with f.*/
2568 opts
->x_flag_trapv
= 0;
2573 opts
->x_flag_wrapv
= 0;
2576 case OPT_fstrict_overflow
:
2577 opts
->x_flag_wrapv
= !value
;
2578 opts
->x_flag_wrapv_pointer
= !value
;
2580 opts
->x_flag_trapv
= 0;
2584 opts
->x_flag_ipa_icf_functions
= value
;
2585 opts
->x_flag_ipa_icf_variables
= value
;
2588 case OPT_falign_loops_
:
2589 check_alignment_argument (loc
, arg
, "loops");
2592 case OPT_falign_jumps_
:
2593 check_alignment_argument (loc
, arg
, "jumps");
2596 case OPT_falign_labels_
:
2597 check_alignment_argument (loc
, arg
, "labels");
2600 case OPT_falign_functions_
:
2601 check_alignment_argument (loc
, arg
, "functions");
2605 /* If the flag was handled in a standard way, assume the lack of
2606 processing here is intentional. */
2607 gcc_assert (option_flag_var (scode
, opts
));
2611 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
2616 /* Handle --param NAME=VALUE. */
2618 handle_param (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2619 location_t loc
, const char *carg
)
2624 arg
= xstrdup (carg
);
2625 equal
= strchr (arg
, '=');
2627 error_at (loc
, "%s: --param arguments should be of the form NAME=VALUE",
2633 enum compiler_param index
;
2634 if (!find_param (arg
, &index
))
2636 const char *suggestion
= find_param_fuzzy (arg
);
2638 error_at (loc
, "invalid --param name %qs; did you mean %qs?",
2641 error_at (loc
, "invalid --param name %qs", arg
);
2645 if (!param_string_value_p (index
, equal
+ 1, &value
))
2646 value
= integral_argument (equal
+ 1);
2649 error_at (loc
, "invalid --param value %qs", equal
+ 1);
2651 set_param_value (arg
, value
,
2652 opts
->x_param_values
, opts_set
->x_param_values
);
2659 /* Used to set the level of strict aliasing warnings in OPTS,
2660 when no level is specified (i.e., when -Wstrict-aliasing, and not
2661 -Wstrict-aliasing=level was given).
2662 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2663 and 0 otherwise. After calling this function, wstrict_aliasing will be
2664 set to the default value of -Wstrict_aliasing=level, currently 3. */
2666 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
2668 gcc_assert (onoff
== 0 || onoff
== 1);
2670 opts
->x_warn_strict_aliasing
= 3;
2672 opts
->x_warn_strict_aliasing
= 0;
2675 /* The following routines are useful in setting all the flags that
2676 -ffast-math and -fno-fast-math imply. */
2678 set_fast_math_flags (struct gcc_options
*opts
, int set
)
2680 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
2682 opts
->x_flag_unsafe_math_optimizations
= set
;
2683 set_unsafe_math_optimizations_flags (opts
, set
);
2685 if (!opts
->frontend_set_flag_finite_math_only
)
2686 opts
->x_flag_finite_math_only
= set
;
2687 if (!opts
->frontend_set_flag_errno_math
)
2688 opts
->x_flag_errno_math
= !set
;
2691 if (opts
->frontend_set_flag_excess_precision_cmdline
2692 == EXCESS_PRECISION_DEFAULT
)
2693 opts
->x_flag_excess_precision_cmdline
2694 = set
? EXCESS_PRECISION_FAST
: EXCESS_PRECISION_DEFAULT
;
2695 if (!opts
->frontend_set_flag_signaling_nans
)
2696 opts
->x_flag_signaling_nans
= 0;
2697 if (!opts
->frontend_set_flag_rounding_math
)
2698 opts
->x_flag_rounding_math
= 0;
2699 if (!opts
->frontend_set_flag_cx_limited_range
)
2700 opts
->x_flag_cx_limited_range
= 1;
2704 /* When -funsafe-math-optimizations is set the following
2705 flags are set as well. */
2707 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
2709 if (!opts
->frontend_set_flag_trapping_math
)
2710 opts
->x_flag_trapping_math
= !set
;
2711 if (!opts
->frontend_set_flag_signed_zeros
)
2712 opts
->x_flag_signed_zeros
= !set
;
2713 if (!opts
->frontend_set_flag_associative_math
)
2714 opts
->x_flag_associative_math
= set
;
2715 if (!opts
->frontend_set_flag_reciprocal_math
)
2716 opts
->x_flag_reciprocal_math
= set
;
2719 /* Return true iff flags in OPTS are set as if -ffast-math. */
2721 fast_math_flags_set_p (const struct gcc_options
*opts
)
2723 return (!opts
->x_flag_trapping_math
2724 && opts
->x_flag_unsafe_math_optimizations
2725 && opts
->x_flag_finite_math_only
2726 && !opts
->x_flag_signed_zeros
2727 && !opts
->x_flag_errno_math
2728 && opts
->x_flag_excess_precision_cmdline
2729 == EXCESS_PRECISION_FAST
);
2732 /* Return true iff flags are set as if -ffast-math but using the flags stored
2733 in the struct cl_optimization structure. */
2735 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
2737 return (!opt
->x_flag_trapping_math
2738 && opt
->x_flag_unsafe_math_optimizations
2739 && opt
->x_flag_finite_math_only
2740 && !opt
->x_flag_signed_zeros
2741 && !opt
->x_flag_errno_math
);
2744 /* Handle a debug output -g switch for options OPTS
2745 (OPTS_SET->x_write_symbols storing whether a debug type was passed
2746 explicitly), location LOC. EXTENDED is true or false to support
2747 extended output (2 is special and means "-ggdb" was given). */
2749 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
,
2750 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2753 opts
->x_use_gnu_debug_info_extensions
= extended
;
2755 if (type
== NO_DEBUG
)
2757 if (opts
->x_write_symbols
== NO_DEBUG
)
2759 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
2763 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
2764 opts
->x_write_symbols
= DWARF2_DEBUG
;
2765 #elif defined DBX_DEBUGGING_INFO
2766 opts
->x_write_symbols
= DBX_DEBUG
;
2770 if (opts
->x_write_symbols
== NO_DEBUG
)
2771 warning_at (loc
, 0, "target system does not support debug output");
2776 /* Does it conflict with an already selected type? */
2777 if (opts_set
->x_write_symbols
!= NO_DEBUG
2778 && opts
->x_write_symbols
!= NO_DEBUG
2779 && type
!= opts
->x_write_symbols
)
2780 error_at (loc
, "debug format %qs conflicts with prior selection",
2781 debug_type_names
[type
]);
2782 opts
->x_write_symbols
= type
;
2783 opts_set
->x_write_symbols
= type
;
2786 /* A debug flag without a level defaults to level 2.
2787 If off or at level 1, set it to level 2, but if already
2788 at level 3, don't lower it. */
2791 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
2792 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
2796 int argval
= integral_argument (arg
);
2798 error_at (loc
, "unrecognized debug output level %qs", arg
);
2799 else if (argval
> 3)
2800 error_at (loc
, "debug output level %qs is too high", arg
);
2802 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
2806 /* Arrange to dump core on error for diagnostic context DC. (The
2807 regular error message is still printed first, except in the case of
2811 setup_core_dumping (diagnostic_context
*dc
)
2814 signal (SIGABRT
, SIG_DFL
);
2816 #if defined(HAVE_SETRLIMIT)
2819 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
2820 fatal_error (input_location
, "getting core file size maximum limit: %m");
2821 rlim
.rlim_cur
= rlim
.rlim_max
;
2822 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
2823 fatal_error (input_location
,
2824 "setting core file size limit to maximum: %m");
2827 diagnostic_abort_on_error (dc
);
2830 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
2831 diagnostic context DC. */
2834 decode_d_option (const char *arg
, struct gcc_options
*opts
,
2835 location_t loc
, diagnostic_context
*dc
)
2843 opts
->x_flag_debug_asm
= 1;
2846 opts
->x_flag_print_asm_name
= 1;
2849 opts
->x_flag_dump_rtl_in_asm
= 1;
2850 opts
->x_flag_print_asm_name
= 1;
2853 opts
->x_rtl_dump_and_exit
= 1;
2855 case 'D': /* These are handled by the preprocessor. */
2862 setup_core_dumping (dc
);
2865 opts
->x_flag_dump_all_passed
= true;
2869 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
2874 /* Enable (or disable if VALUE is 0) a warning option ARG (language
2875 mask LANG_MASK, option handlers HANDLERS) as an error for option
2876 structures OPTS and OPTS_SET, diagnostic context DC (possibly
2877 NULL), location LOC. This is used by -Werror=. */
2880 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
2881 const struct cl_option_handlers
*handlers
,
2882 struct gcc_options
*opts
,
2883 struct gcc_options
*opts_set
,
2884 location_t loc
, diagnostic_context
*dc
)
2889 new_option
= XNEWVEC (char, strlen (arg
) + 2);
2890 new_option
[0] = 'W';
2891 strcpy (new_option
+ 1, arg
);
2892 option_index
= find_opt (new_option
, lang_mask
);
2893 if (option_index
== OPT_SPECIAL_unknown
)
2894 error_at (loc
, "-Werror=%s: no option -%s", arg
, new_option
);
2895 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
2896 error_at (loc
, "-Werror=%s: -%s is not an option that controls warnings",
2900 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
2901 const char *arg
= NULL
;
2903 if (cl_options
[option_index
].flags
& CL_JOINED
)
2904 arg
= new_option
+ cl_options
[option_index
].opt_len
;
2905 control_warning_option (option_index
, (int) kind
, arg
, value
,
2907 handlers
, opts
, opts_set
, dc
);
2912 /* Return malloced memory for the name of the option OPTION_INDEX
2913 which enabled a diagnostic (context CONTEXT), originally of type
2914 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2918 option_name (diagnostic_context
*context
, int option_index
,
2919 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
2923 /* A warning classified as an error. */
2924 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
2925 && diag_kind
== DK_ERROR
)
2926 return concat (cl_options
[OPT_Werror_
].opt_text
,
2927 /* Skip over "-W". */
2928 cl_options
[option_index
].opt_text
+ 2,
2930 /* A warning with option. */
2932 return xstrdup (cl_options
[option_index
].opt_text
);
2934 /* A warning without option classified as an error. */
2935 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
2936 || diag_kind
== DK_WARNING
)
2937 && context
->warning_as_error_requested
)
2938 return xstrdup (cl_options
[OPT_Werror
].opt_text
);