1 /* Command line option handling.
2 Copyright (C) 2002-2016 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"
34 static void set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
);
36 /* Indexed by enum debug_info_type. */
37 const char *const debug_type_names
[] =
39 "none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
42 /* Parse the -femit-struct-debug-detailed option value
43 and set the flag variables. */
45 #define MATCH( prefix, string ) \
46 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
47 ? ((string += sizeof prefix - 1), 1) : 0)
50 set_struct_debug_option (struct gcc_options
*opts
, location_t loc
,
53 /* various labels for comparison */
54 static const char dfn_lbl
[] = "dfn:", dir_lbl
[] = "dir:", ind_lbl
[] = "ind:";
55 static const char ord_lbl
[] = "ord:", gen_lbl
[] = "gen:";
56 static const char none_lbl
[] = "none", any_lbl
[] = "any";
57 static const char base_lbl
[] = "base", sys_lbl
[] = "sys";
59 enum debug_struct_file files
= DINFO_STRUCT_FILE_ANY
;
60 /* Default is to apply to as much as possible. */
61 enum debug_info_usage usage
= DINFO_USAGE_NUM_ENUMS
;
65 if (MATCH (dfn_lbl
, spec
))
66 usage
= DINFO_USAGE_DFN
;
67 else if (MATCH (dir_lbl
, spec
))
68 usage
= DINFO_USAGE_DIR_USE
;
69 else if (MATCH (ind_lbl
, spec
))
70 usage
= DINFO_USAGE_IND_USE
;
72 /* Generics or not? */
73 if (MATCH (ord_lbl
, spec
))
75 else if (MATCH (gen_lbl
, spec
))
78 /* What allowable environment? */
79 if (MATCH (none_lbl
, spec
))
80 files
= DINFO_STRUCT_FILE_NONE
;
81 else if (MATCH (any_lbl
, spec
))
82 files
= DINFO_STRUCT_FILE_ANY
;
83 else if (MATCH (sys_lbl
, spec
))
84 files
= DINFO_STRUCT_FILE_SYS
;
85 else if (MATCH (base_lbl
, spec
))
86 files
= DINFO_STRUCT_FILE_BASE
;
89 "argument %qs to %<-femit-struct-debug-detailed%> "
93 /* Effect the specification. */
94 if (usage
== DINFO_USAGE_NUM_ENUMS
)
98 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DFN
] = files
;
99 opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
] = files
;
100 opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
] = files
;
104 opts
->x_debug_struct_generic
[DINFO_USAGE_DFN
] = files
;
105 opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
] = files
;
106 opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
] = files
;
112 opts
->x_debug_struct_ordinary
[usage
] = files
;
114 opts
->x_debug_struct_generic
[usage
] = files
;
118 set_struct_debug_option (opts
, loc
, spec
+1);
121 /* No more -femit-struct-debug-detailed specifications.
125 "argument %qs to %<-femit-struct-debug-detailed%> unknown",
127 if (opts
->x_debug_struct_ordinary
[DINFO_USAGE_DIR_USE
]
128 < opts
->x_debug_struct_ordinary
[DINFO_USAGE_IND_USE
]
129 || opts
->x_debug_struct_generic
[DINFO_USAGE_DIR_USE
]
130 < opts
->x_debug_struct_generic
[DINFO_USAGE_IND_USE
])
132 "%<-femit-struct-debug-detailed=dir:...%> must allow "
133 "at least as much as "
134 "%<-femit-struct-debug-detailed=ind:...%>");
138 /* Strip off a legitimate source ending from the input string NAME of
139 length LEN. Rather than having to know the names used by all of
140 our front ends, we strip off an ending of a period followed by
141 up to five characters. (Java uses ".class".) */
144 strip_off_ending (char *name
, int len
)
147 for (i
= 2; i
< 6 && len
> i
; i
++)
149 if (name
[len
- i
] == '.')
151 name
[len
- i
] = '\0';
157 /* Find the base name of a path, stripping off both directories and
158 a single final extension. */
160 base_of_path (const char *path
, const char **base_out
)
162 const char *base
= path
;
164 const char *p
= path
;
168 if (IS_DIR_SEPARATOR (c
))
183 /* What to print when a switch has no documentation. */
184 static const char undocumented_msg
[] = N_("This option lacks documentation.");
185 static const char use_diagnosed_msg
[] = N_("Uses of this option are diagnosed.");
187 typedef char *char_p
; /* For DEF_VEC_P. */
189 static void handle_param (struct gcc_options
*opts
,
190 struct gcc_options
*opts_set
, location_t loc
,
192 static void set_debug_level (enum debug_info_type type
, int extended
,
193 const char *arg
, struct gcc_options
*opts
,
194 struct gcc_options
*opts_set
,
196 static void set_fast_math_flags (struct gcc_options
*opts
, int set
);
197 static void decode_d_option (const char *arg
, struct gcc_options
*opts
,
198 location_t loc
, diagnostic_context
*dc
);
199 static void set_unsafe_math_optimizations_flags (struct gcc_options
*opts
,
201 static void enable_warning_as_error (const char *arg
, int value
,
202 unsigned int lang_mask
,
203 const struct cl_option_handlers
*handlers
,
204 struct gcc_options
*opts
,
205 struct gcc_options
*opts_set
,
207 diagnostic_context
*dc
);
209 /* Handle a back-end option; arguments and return value as for
213 target_handle_option (struct gcc_options
*opts
,
214 struct gcc_options
*opts_set
,
215 const struct cl_decoded_option
*decoded
,
216 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
218 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
219 diagnostic_context
*dc
)
221 gcc_assert (dc
== global_dc
);
222 gcc_assert (kind
== DK_UNSPECIFIED
);
223 return targetm_common
.handle_option (opts
, opts_set
, decoded
, loc
);
226 /* Add comma-separated strings to a char_p vector. */
229 add_comma_separated_to_vector (void **pvec
, const char *arg
)
235 vec
<char_p
> *v
= (vec
<char_p
> *) *pvec
;
237 vec_check_alloc (v
, 1);
239 /* We never free this string. */
252 v
->safe_push (token_start
);
255 if (*r
== '\\' && r
[1] == ',')
263 if (*token_start
!= '\0')
264 v
->safe_push (token_start
);
269 /* Initialize opts_obstack. */
272 init_opts_obstack (void)
274 gcc_obstack_init (&opts_obstack
);
277 /* Initialize OPTS and OPTS_SET before using them in parsing options. */
280 init_options_struct (struct gcc_options
*opts
, struct gcc_options
*opts_set
)
282 size_t num_params
= get_num_compiler_params ();
284 /* Ensure that opts_obstack has already been initialized by the time
285 that we initialize any gcc_options instances (PR jit/68446). */
286 gcc_assert (opts_obstack
.chunk_size
> 0);
288 *opts
= global_options_init
;
291 memset (opts_set
, 0, sizeof (*opts_set
));
293 opts
->x_param_values
= XNEWVEC (int, num_params
);
296 opts_set
->x_param_values
= XCNEWVEC (int, num_params
);
298 init_param_values (opts
->x_param_values
);
300 /* Initialize whether `char' is signed. */
301 opts
->x_flag_signed_char
= DEFAULT_SIGNED_CHAR
;
302 /* Set this to a special "uninitialized" value. The actual default
303 is set after target options have been processed. */
304 opts
->x_flag_short_enums
= 2;
306 /* Initialize target_flags before default_options_optimization
307 so the latter can modify it. */
308 opts
->x_target_flags
= targetm_common
.default_target_flags
;
310 /* Some targets have ABI-specified unwind tables. */
311 opts
->x_flag_unwind_tables
= targetm_common
.unwind_tables_default
;
313 /* Some targets have other target-specific initialization. */
314 targetm_common
.option_init_struct (opts
);
317 /* Release any allocations owned by OPTS. */
320 finalize_options_struct (struct gcc_options
*opts
)
322 XDELETEVEC (opts
->x_param_values
);
325 /* If indicated by the optimization level LEVEL (-Os if SIZE is set,
326 -Ofast if FAST is set, -Og if DEBUG is set), apply the option DEFAULT_OPT
327 to OPTS and OPTS_SET, diagnostic context DC, location LOC, with language
328 mask LANG_MASK and option handlers HANDLERS. */
331 maybe_default_option (struct gcc_options
*opts
,
332 struct gcc_options
*opts_set
,
333 const struct default_options
*default_opt
,
334 int level
, bool size
, bool fast
, bool debug
,
335 unsigned int lang_mask
,
336 const struct cl_option_handlers
*handlers
,
338 diagnostic_context
*dc
)
340 const struct cl_option
*option
= &cl_options
[default_opt
->opt_index
];
344 gcc_assert (level
== 2);
346 gcc_assert (level
== 3);
348 gcc_assert (level
== 1);
350 switch (default_opt
->levels
)
356 case OPT_LEVELS_0_ONLY
:
357 enabled
= (level
== 0);
360 case OPT_LEVELS_1_PLUS
:
361 enabled
= (level
>= 1);
364 case OPT_LEVELS_1_PLUS_SPEED_ONLY
:
365 enabled
= (level
>= 1 && !size
&& !debug
);
368 case OPT_LEVELS_1_PLUS_NOT_DEBUG
:
369 enabled
= (level
>= 1 && !debug
);
372 case OPT_LEVELS_2_PLUS
:
373 enabled
= (level
>= 2);
376 case OPT_LEVELS_2_PLUS_SPEED_ONLY
:
377 enabled
= (level
>= 2 && !size
&& !debug
);
380 case OPT_LEVELS_3_PLUS
:
381 enabled
= (level
>= 3);
384 case OPT_LEVELS_3_PLUS_AND_SIZE
:
385 enabled
= (level
>= 3 || size
);
388 case OPT_LEVELS_SIZE
:
392 case OPT_LEVELS_FAST
:
396 case OPT_LEVELS_NONE
:
402 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
403 default_opt
->arg
, default_opt
->value
,
404 lang_mask
, DK_UNSPECIFIED
, loc
,
406 else if (default_opt
->arg
== NULL
407 && !option
->cl_reject_negative
)
408 handle_generated_option (opts
, opts_set
, default_opt
->opt_index
,
409 default_opt
->arg
, !default_opt
->value
,
410 lang_mask
, DK_UNSPECIFIED
, loc
,
414 /* As indicated by the optimization level LEVEL (-Os if SIZE is set,
415 -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
416 OPTS and OPTS_SET, diagnostic context DC, location LOC, with
417 language mask LANG_MASK and option handlers HANDLERS. */
420 maybe_default_options (struct gcc_options
*opts
,
421 struct gcc_options
*opts_set
,
422 const struct default_options
*default_opts
,
423 int level
, bool size
, bool fast
, bool debug
,
424 unsigned int lang_mask
,
425 const struct cl_option_handlers
*handlers
,
427 diagnostic_context
*dc
)
431 for (i
= 0; default_opts
[i
].levels
!= OPT_LEVELS_NONE
; i
++)
432 maybe_default_option (opts
, opts_set
, &default_opts
[i
],
433 level
, size
, fast
, debug
,
434 lang_mask
, handlers
, loc
, dc
);
437 /* Table of options enabled by default at different levels. */
439 static const struct default_options default_options_table
[] =
441 /* -O1 optimizations. */
442 { OPT_LEVELS_1_PLUS
, OPT_fdefer_pop
, NULL
, 1 },
444 { OPT_LEVELS_1_PLUS
, OPT_fdelayed_branch
, NULL
, 1 },
446 { OPT_LEVELS_1_PLUS
, OPT_fguess_branch_probability
, NULL
, 1 },
447 { OPT_LEVELS_1_PLUS
, OPT_fcprop_registers
, NULL
, 1 },
448 { OPT_LEVELS_1_PLUS
, OPT_fforward_propagate
, NULL
, 1 },
449 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion
, NULL
, 1 },
450 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fif_conversion2
, NULL
, 1 },
451 { OPT_LEVELS_1_PLUS
, OPT_fipa_pure_const
, NULL
, 1 },
452 { OPT_LEVELS_1_PLUS
, OPT_fipa_reference
, NULL
, 1 },
453 { OPT_LEVELS_1_PLUS
, OPT_fipa_profile
, NULL
, 1 },
454 { OPT_LEVELS_1_PLUS
, OPT_fmerge_constants
, NULL
, 1 },
455 { OPT_LEVELS_1_PLUS
, OPT_freorder_blocks
, NULL
, 1 },
456 { OPT_LEVELS_1_PLUS
, OPT_fshrink_wrap
, NULL
, 1 },
457 { OPT_LEVELS_1_PLUS
, OPT_fsplit_wide_types
, NULL
, 1 },
458 { OPT_LEVELS_1_PLUS
, OPT_ftree_ccp
, NULL
, 1 },
459 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_bit_ccp
, NULL
, 1 },
460 { OPT_LEVELS_1_PLUS
, OPT_ftree_coalesce_vars
, NULL
, 1 },
461 { OPT_LEVELS_1_PLUS
, OPT_ftree_dce
, NULL
, 1 },
462 { OPT_LEVELS_1_PLUS
, OPT_ftree_dominator_opts
, NULL
, 1 },
463 { OPT_LEVELS_1_PLUS
, OPT_ftree_dse
, NULL
, 1 },
464 { OPT_LEVELS_1_PLUS
, OPT_ftree_ter
, NULL
, 1 },
465 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_sra
, NULL
, 1 },
466 { OPT_LEVELS_1_PLUS
, OPT_ftree_fre
, NULL
, 1 },
467 { OPT_LEVELS_1_PLUS
, OPT_ftree_copy_prop
, NULL
, 1 },
468 { OPT_LEVELS_1_PLUS
, OPT_ftree_sink
, NULL
, 1 },
469 { OPT_LEVELS_1_PLUS
, OPT_ftree_ch
, NULL
, 1 },
470 { OPT_LEVELS_1_PLUS
, OPT_fcombine_stack_adjustments
, NULL
, 1 },
471 { OPT_LEVELS_1_PLUS
, OPT_fcompare_elim
, NULL
, 1 },
472 { OPT_LEVELS_1_PLUS
, OPT_ftree_slsr
, NULL
, 1 },
473 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fbranch_count_reg
, NULL
, 1 },
474 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fmove_loop_invariants
, NULL
, 1 },
475 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_ftree_pta
, NULL
, 1 },
476 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_fssa_phiopt
, NULL
, 1 },
477 { OPT_LEVELS_1_PLUS
, OPT_ftree_builtin_call_dce
, NULL
, 1 },
479 /* -O2 optimizations. */
480 { OPT_LEVELS_2_PLUS
, OPT_finline_small_functions
, NULL
, 1 },
481 { OPT_LEVELS_2_PLUS
, OPT_findirect_inlining
, NULL
, 1 },
482 { OPT_LEVELS_2_PLUS
, OPT_fpartial_inlining
, NULL
, 1 },
483 { OPT_LEVELS_2_PLUS
, OPT_fthread_jumps
, NULL
, 1 },
484 { OPT_LEVELS_2_PLUS
, OPT_fcrossjumping
, NULL
, 1 },
485 { OPT_LEVELS_2_PLUS
, OPT_foptimize_sibling_calls
, NULL
, 1 },
486 { OPT_LEVELS_2_PLUS
, OPT_fcse_follow_jumps
, NULL
, 1 },
487 { OPT_LEVELS_2_PLUS
, OPT_fgcse
, NULL
, 1 },
488 { OPT_LEVELS_2_PLUS
, OPT_fexpensive_optimizations
, NULL
, 1 },
489 { OPT_LEVELS_2_PLUS
, OPT_frerun_cse_after_loop
, NULL
, 1 },
490 { OPT_LEVELS_2_PLUS
, OPT_fcaller_saves
, NULL
, 1 },
491 { OPT_LEVELS_2_PLUS
, OPT_fpeephole2
, NULL
, 1 },
492 #ifdef INSN_SCHEDULING
493 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
494 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_fschedule_insns
, NULL
, 1 },
495 { OPT_LEVELS_2_PLUS
, OPT_fschedule_insns2
, NULL
, 1 },
497 { OPT_LEVELS_2_PLUS
, OPT_fstrict_aliasing
, NULL
, 1 },
498 { OPT_LEVELS_2_PLUS
, OPT_fstrict_overflow
, NULL
, 1 },
499 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_freorder_blocks_algorithm_
, NULL
,
500 REORDER_BLOCKS_ALGORITHM_STC
},
501 { OPT_LEVELS_2_PLUS
, OPT_freorder_functions
, NULL
, 1 },
502 { OPT_LEVELS_2_PLUS
, OPT_ftree_vrp
, NULL
, 1 },
503 { OPT_LEVELS_2_PLUS
, OPT_fcode_hoisting
, NULL
, 1 },
504 { OPT_LEVELS_2_PLUS
, OPT_ftree_pre
, NULL
, 1 },
505 { OPT_LEVELS_2_PLUS
, OPT_ftree_switch_conversion
, NULL
, 1 },
506 { OPT_LEVELS_2_PLUS
, OPT_fipa_cp
, NULL
, 1 },
507 { OPT_LEVELS_2_PLUS
, OPT_fipa_cp_alignment
, NULL
, 1 },
508 { OPT_LEVELS_2_PLUS
, OPT_fipa_bit_cp
, NULL
, 1 },
509 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize
, NULL
, 1 },
510 { OPT_LEVELS_2_PLUS
, OPT_fdevirtualize_speculatively
, NULL
, 1 },
511 { OPT_LEVELS_2_PLUS
, OPT_fipa_sra
, NULL
, 1 },
512 { OPT_LEVELS_2_PLUS
, OPT_falign_loops
, NULL
, 1 },
513 { OPT_LEVELS_2_PLUS
, OPT_falign_jumps
, NULL
, 1 },
514 { OPT_LEVELS_2_PLUS
, OPT_falign_labels
, NULL
, 1 },
515 { OPT_LEVELS_2_PLUS
, OPT_falign_functions
, NULL
, 1 },
516 { OPT_LEVELS_2_PLUS
, OPT_ftree_tail_merge
, NULL
, 1 },
517 { OPT_LEVELS_2_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_CHEAP
},
518 { OPT_LEVELS_2_PLUS_SPEED_ONLY
, OPT_foptimize_strlen
, NULL
, 1 },
519 { OPT_LEVELS_2_PLUS
, OPT_fhoist_adjacent_loads
, NULL
, 1 },
520 { OPT_LEVELS_2_PLUS
, OPT_fipa_icf
, NULL
, 1 },
521 { OPT_LEVELS_2_PLUS
, OPT_fisolate_erroneous_paths_dereference
, NULL
, 1 },
522 { OPT_LEVELS_2_PLUS
, OPT_fipa_ra
, NULL
, 1 },
523 { OPT_LEVELS_2_PLUS
, OPT_flra_remat
, NULL
, 1 },
525 /* -O3 optimizations. */
526 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_distribute_patterns
, NULL
, 1 },
527 { OPT_LEVELS_3_PLUS
, OPT_fpredictive_commoning
, NULL
, 1 },
528 { OPT_LEVELS_3_PLUS
, OPT_fsplit_paths
, NULL
, 1 },
529 /* Inlining of functions reducing size is a good idea with -Os
530 regardless of them being declared inline. */
531 { OPT_LEVELS_3_PLUS_AND_SIZE
, OPT_finline_functions
, NULL
, 1 },
532 { OPT_LEVELS_1_PLUS_NOT_DEBUG
, OPT_finline_functions_called_once
, NULL
, 1 },
533 { OPT_LEVELS_3_PLUS
, OPT_funswitch_loops
, NULL
, 1 },
534 { OPT_LEVELS_3_PLUS
, OPT_fgcse_after_reload
, NULL
, 1 },
535 { OPT_LEVELS_3_PLUS
, OPT_ftree_loop_vectorize
, NULL
, 1 },
536 { OPT_LEVELS_3_PLUS
, OPT_ftree_slp_vectorize
, NULL
, 1 },
537 { OPT_LEVELS_3_PLUS
, OPT_fvect_cost_model_
, NULL
, VECT_COST_MODEL_DYNAMIC
},
538 { OPT_LEVELS_3_PLUS
, OPT_fipa_cp_clone
, NULL
, 1 },
539 { OPT_LEVELS_3_PLUS
, OPT_ftree_partial_pre
, NULL
, 1 },
540 { OPT_LEVELS_3_PLUS
, OPT_fpeel_loops
, NULL
, 1 },
542 /* -Ofast adds optimizations to -O3. */
543 { OPT_LEVELS_FAST
, OPT_ffast_math
, NULL
, 1 },
545 { OPT_LEVELS_NONE
, 0, NULL
, 0 }
548 /* Default the options in OPTS and OPTS_SET based on the optimization
549 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
551 default_options_optimization (struct gcc_options
*opts
,
552 struct gcc_options
*opts_set
,
553 struct cl_decoded_option
*decoded_options
,
554 unsigned int decoded_options_count
,
556 unsigned int lang_mask
,
557 const struct cl_option_handlers
*handlers
,
558 diagnostic_context
*dc
)
562 bool openacc_mode
= false;
564 /* Scan to see what optimization level has been specified. That will
565 determine the default value of many flags. */
566 for (i
= 1; i
< decoded_options_count
; i
++)
568 struct cl_decoded_option
*opt
= &decoded_options
[i
];
569 switch (opt
->opt_index
)
572 if (*opt
->arg
== '\0')
574 opts
->x_optimize
= 1;
575 opts
->x_optimize_size
= 0;
576 opts
->x_optimize_fast
= 0;
577 opts
->x_optimize_debug
= 0;
581 const int optimize_val
= integral_argument (opt
->arg
);
582 if (optimize_val
== -1)
583 error_at (loc
, "argument to %<-O%> should be a non-negative "
584 "integer, %<g%>, %<s%> or %<fast%>");
587 opts
->x_optimize
= optimize_val
;
588 if ((unsigned int) opts
->x_optimize
> 255)
589 opts
->x_optimize
= 255;
590 opts
->x_optimize_size
= 0;
591 opts
->x_optimize_fast
= 0;
592 opts
->x_optimize_debug
= 0;
598 opts
->x_optimize_size
= 1;
600 /* Optimizing for size forces optimize to be 2. */
601 opts
->x_optimize
= 2;
602 opts
->x_optimize_fast
= 0;
603 opts
->x_optimize_debug
= 0;
607 /* -Ofast only adds flags to -O3. */
608 opts
->x_optimize_size
= 0;
609 opts
->x_optimize
= 3;
610 opts
->x_optimize_fast
= 1;
611 opts
->x_optimize_debug
= 0;
615 /* -Og selects optimization level 1. */
616 opts
->x_optimize_size
= 0;
617 opts
->x_optimize
= 1;
618 opts
->x_optimize_fast
= 0;
619 opts
->x_optimize_debug
= 1;
628 /* Ignore other options in this prescan. */
633 maybe_default_options (opts
, opts_set
, default_options_table
,
634 opts
->x_optimize
, opts
->x_optimize_size
,
635 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
636 lang_mask
, handlers
, loc
, dc
);
638 /* -O2 param settings. */
639 opt2
= (opts
->x_optimize
>= 2);
642 && !opts_set
->x_flag_ipa_pta
)
643 opts
->x_flag_ipa_pta
= true;
645 /* Track fields in field-sensitive alias analysis. */
646 maybe_set_param_value
647 (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
,
648 opt2
? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE
),
649 opts
->x_param_values
, opts_set
->x_param_values
);
651 /* For -O1 only do loop invariant motion for very small loops. */
652 maybe_set_param_value
653 (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
,
654 opt2
? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP
) : 1000,
655 opts
->x_param_values
, opts_set
->x_param_values
);
657 /* At -Ofast, allow store motion to introduce potential race conditions. */
658 maybe_set_param_value
659 (PARAM_ALLOW_STORE_DATA_RACES
,
660 opts
->x_optimize_fast
? 1
661 : default_param_value (PARAM_ALLOW_STORE_DATA_RACES
),
662 opts
->x_param_values
, opts_set
->x_param_values
);
664 if (opts
->x_optimize_size
)
665 /* We want to crossjump as much as possible. */
666 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
, 1,
667 opts
->x_param_values
, opts_set
->x_param_values
);
669 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS
,
670 default_param_value (PARAM_MIN_CROSSJUMP_INSNS
),
671 opts
->x_param_values
, opts_set
->x_param_values
);
673 /* Restrict the amount of work combine does at -Og while retaining
674 most of its useful transforms. */
675 if (opts
->x_optimize_debug
)
676 maybe_set_param_value (PARAM_MAX_COMBINE_INSNS
, 2,
677 opts
->x_param_values
, opts_set
->x_param_values
);
679 /* Allow default optimizations to be specified on a per-machine basis. */
680 maybe_default_options (opts
, opts_set
,
681 targetm_common
.option_optimization_table
,
682 opts
->x_optimize
, opts
->x_optimize_size
,
683 opts
->x_optimize_fast
, opts
->x_optimize_debug
,
684 lang_mask
, handlers
, loc
, dc
);
687 /* After all options at LOC have been read into OPTS and OPTS_SET,
688 finalize settings of those options and diagnose incompatible
691 finish_options (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
694 enum unwind_info_type ui_except
;
696 if (opts
->x_dump_base_name
697 && ! IS_ABSOLUTE_PATH (opts
->x_dump_base_name
)
698 && ! opts
->x_dump_base_name_prefixed
)
700 /* First try to make OPTS->X_DUMP_BASE_NAME relative to the
701 OPTS->X_DUMP_DIR_NAME directory. Then try to make
702 OPTS->X_DUMP_BASE_NAME relative to the OPTS->X_AUX_BASE_NAME
703 directory, typically the directory to contain the object
705 if (opts
->x_dump_dir_name
)
706 opts
->x_dump_base_name
= opts_concat (opts
->x_dump_dir_name
,
707 opts
->x_dump_base_name
, NULL
);
708 else if (opts
->x_aux_base_name
709 && strcmp (opts
->x_aux_base_name
, HOST_BIT_BUCKET
) != 0)
711 const char *aux_base
;
713 base_of_path (opts
->x_aux_base_name
, &aux_base
);
714 if (opts
->x_aux_base_name
!= aux_base
)
716 int dir_len
= aux_base
- opts
->x_aux_base_name
;
717 char *new_dump_base_name
718 = XOBNEWVEC (&opts_obstack
, char,
719 strlen (opts
->x_dump_base_name
) + dir_len
+ 1);
721 /* Copy directory component from OPTS->X_AUX_BASE_NAME. */
722 memcpy (new_dump_base_name
, opts
->x_aux_base_name
, dir_len
);
723 /* Append existing OPTS->X_DUMP_BASE_NAME. */
724 strcpy (new_dump_base_name
+ dir_len
, opts
->x_dump_base_name
);
725 opts
->x_dump_base_name
= new_dump_base_name
;
728 opts
->x_dump_base_name_prefixed
= true;
731 /* Handle related options for unit-at-a-time, toplevel-reorder, and
733 if (!opts
->x_flag_unit_at_a_time
)
735 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
736 error_at (loc
, "section anchors must be disabled when unit-at-a-time "
738 opts
->x_flag_section_anchors
= 0;
739 if (opts
->x_flag_toplevel_reorder
== 1)
740 error_at (loc
, "toplevel reorder must be disabled when unit-at-a-time "
742 opts
->x_flag_toplevel_reorder
= 0;
745 if (opts
->x_flag_tm
&& opts
->x_flag_non_call_exceptions
)
746 sorry ("transactional memory is not supported with non-call exceptions");
748 /* Unless the user has asked for section anchors, we disable toplevel
749 reordering at -O0 to disable transformations that might be surprising
750 to end users and to get -fno-toplevel-reorder tested. */
751 if (!opts
->x_optimize
752 && opts
->x_flag_toplevel_reorder
== 2
753 && !(opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
))
755 opts
->x_flag_toplevel_reorder
= 0;
756 opts
->x_flag_section_anchors
= 0;
758 if (!opts
->x_flag_toplevel_reorder
)
760 if (opts
->x_flag_section_anchors
&& opts_set
->x_flag_section_anchors
)
761 error_at (loc
, "section anchors must be disabled when toplevel reorder"
763 opts
->x_flag_section_anchors
= 0;
766 if (!opts
->x_flag_opts_finished
)
768 /* We initialize opts->x_flag_pie to -1 so that targets can set a
770 if (opts
->x_flag_pie
== -1)
772 /* We initialize opts->x_flag_pic to -1 so that we can tell if
773 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
774 if (opts
->x_flag_pic
== -1)
775 opts
->x_flag_pie
= DEFAULT_FLAG_PIE
;
777 opts
->x_flag_pie
= 0;
779 /* If -fPIE or -fpie is used, turn on PIC. */
780 if (opts
->x_flag_pie
)
781 opts
->x_flag_pic
= opts
->x_flag_pie
;
782 else if (opts
->x_flag_pic
== -1)
783 opts
->x_flag_pic
= 0;
784 if (opts
->x_flag_pic
&& !opts
->x_flag_pie
)
785 opts
->x_flag_shlib
= 1;
786 opts
->x_flag_opts_finished
= true;
789 /* We initialize opts->x_flag_stack_protect to -1 so that targets
790 can set a default value. */
791 if (opts
->x_flag_stack_protect
== -1)
792 opts
->x_flag_stack_protect
= DEFAULT_FLAG_SSP
;
794 if (opts
->x_optimize
== 0)
796 /* Inlining does not work if not optimizing,
797 so force it not to be done. */
798 opts
->x_warn_inline
= 0;
799 opts
->x_flag_no_inline
= 1;
802 /* The optimization to partition hot and cold basic blocks into separate
803 sections of the .o and executable files does not work (currently)
804 with exception handling. This is because there is no support for
805 generating unwind info. If opts->x_flag_exceptions is turned on
806 we need to turn off the partitioning optimization. */
808 ui_except
= targetm_common
.except_unwind_info (opts
);
810 if (opts
->x_flag_exceptions
811 && opts
->x_flag_reorder_blocks_and_partition
812 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
814 if (opts_set
->x_flag_reorder_blocks_and_partition
)
816 "-freorder-blocks-and-partition does not work "
817 "with exceptions on this architecture");
818 opts
->x_flag_reorder_blocks_and_partition
= 0;
819 opts
->x_flag_reorder_blocks
= 1;
822 /* If user requested unwind info, then turn off the partitioning
825 if (opts
->x_flag_unwind_tables
826 && !targetm_common
.unwind_tables_default
827 && opts
->x_flag_reorder_blocks_and_partition
828 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))
830 if (opts_set
->x_flag_reorder_blocks_and_partition
)
832 "-freorder-blocks-and-partition does not support "
833 "unwind info on this architecture");
834 opts
->x_flag_reorder_blocks_and_partition
= 0;
835 opts
->x_flag_reorder_blocks
= 1;
838 /* If the target requested unwind info, then turn off the partitioning
839 optimization with a different message. Likewise, if the target does not
840 support named sections. */
842 if (opts
->x_flag_reorder_blocks_and_partition
843 && (!targetm_common
.have_named_sections
844 || (opts
->x_flag_unwind_tables
845 && targetm_common
.unwind_tables_default
846 && (ui_except
== UI_SJLJ
|| ui_except
>= UI_TARGET
))))
848 if (opts_set
->x_flag_reorder_blocks_and_partition
)
850 "-freorder-blocks-and-partition does not work "
851 "on this architecture");
852 opts
->x_flag_reorder_blocks_and_partition
= 0;
853 opts
->x_flag_reorder_blocks
= 1;
856 /* Disable -freorder-blocks-and-partition when -fprofile-use is not in
857 effect. Function splitting was not actually being performed in that case,
858 as probably_never_executed_bb_p does not distinguish any basic blocks as
859 being cold vs hot when there is no profile data. Leaving it enabled,
860 however, causes the assembly code generator to create (empty) cold
861 sections and labels, leading to unnecessary size overhead. */
862 if (opts
->x_flag_reorder_blocks_and_partition
863 && !opts_set
->x_flag_profile_use
)
864 opts
->x_flag_reorder_blocks_and_partition
= 0;
866 if (opts
->x_flag_reorder_blocks_and_partition
867 && !opts_set
->x_flag_reorder_functions
)
868 opts
->x_flag_reorder_functions
= 1;
870 /* Pipelining of outer loops is only possible when general pipelining
871 capabilities are requested. */
872 if (!opts
->x_flag_sel_sched_pipelining
)
873 opts
->x_flag_sel_sched_pipelining_outer_loops
= 0;
875 if (opts
->x_flag_conserve_stack
)
877 maybe_set_param_value (PARAM_LARGE_STACK_FRAME
, 100,
878 opts
->x_param_values
, opts_set
->x_param_values
);
879 maybe_set_param_value (PARAM_STACK_FRAME_GROWTH
, 40,
880 opts
->x_param_values
, opts_set
->x_param_values
);
883 if (opts
->x_flag_lto
)
886 opts
->x_flag_generate_lto
= 1;
888 /* When generating IL, do not operate in whole-program mode.
889 Otherwise, symbols will be privatized too early, causing link
891 opts
->x_flag_whole_program
= 0;
893 error_at (loc
, "LTO support has not been enabled in this configuration");
895 if (!opts
->x_flag_fat_lto_objects
897 || (opts_set
->x_flag_use_linker_plugin
898 && !opts
->x_flag_use_linker_plugin
)))
900 if (opts_set
->x_flag_fat_lto_objects
)
901 error_at (loc
, "-fno-fat-lto-objects are supported only with linker plugin");
902 opts
->x_flag_fat_lto_objects
= 1;
906 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
907 default value if they choose based on other options. */
908 if (opts
->x_flag_split_stack
== -1)
909 opts
->x_flag_split_stack
= 0;
910 else if (opts
->x_flag_split_stack
)
912 if (!targetm_common
.supports_split_stack (true, opts
))
914 error_at (loc
, "%<-fsplit-stack%> is not supported by "
915 "this compiler configuration");
916 opts
->x_flag_split_stack
= 0;
920 /* Tune vectorization related parametees according to cost model. */
921 if (opts
->x_flag_vect_cost_model
== VECT_COST_MODEL_CHEAP
)
923 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS
,
924 6, opts
->x_param_values
, opts_set
->x_param_values
);
925 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS
,
926 0, opts
->x_param_values
, opts_set
->x_param_values
);
927 maybe_set_param_value (PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT
,
928 0, opts
->x_param_values
, opts_set
->x_param_values
);
931 /* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
933 if ((!opts
->x_flag_tree_loop_vectorize
&& !opts
->x_flag_tree_slp_vectorize
)
934 || !opts
->x_flag_tree_loop_if_convert
)
935 maybe_set_param_value (PARAM_MAX_STORES_TO_SINK
, 0,
936 opts
->x_param_values
, opts_set
->x_param_values
);
938 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
939 if (opts
->x_dwarf_split_debug_info
)
940 opts
->x_debug_generate_pub_sections
= 2;
942 /* Userspace and kernel ASan conflict with each other. */
944 if ((opts
->x_flag_sanitize
& SANITIZE_USER_ADDRESS
)
945 && (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
))
947 "-fsanitize=address is incompatible with "
948 "-fsanitize=kernel-address");
952 if ((opts
->x_flag_sanitize
& SANITIZE_ADDRESS
)
953 && (opts
->x_flag_sanitize
& SANITIZE_THREAD
))
955 "-fsanitize=address and -fsanitize=kernel-address "
956 "are incompatible with -fsanitize=thread");
958 /* Error recovery is not allowed for LSan and TSan. */
960 if (opts
->x_flag_sanitize_recover
& SANITIZE_THREAD
)
961 error_at (loc
, "-fsanitize-recover=thread is not supported");
963 if (opts
->x_flag_sanitize_recover
& SANITIZE_LEAK
)
964 error_at (loc
, "-fsanitize-recover=leak is not supported");
966 /* When instrumenting the pointers, we don't want to remove
967 the null pointer checks. */
968 if (opts
->x_flag_sanitize
& (SANITIZE_NULL
| SANITIZE_NONNULL_ATTRIBUTE
969 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE
))
970 opts
->x_flag_delete_null_pointer_checks
= 0;
972 /* Aggressive compiler optimizations may cause false negatives. */
973 if (opts
->x_flag_sanitize
)
975 opts
->x_flag_aggressive_loop_optimizations
= 0;
976 opts
->x_flag_strict_overflow
= 0;
980 #define LEFT_COLUMN 27
982 /* Output ITEM, of length ITEM_WIDTH, in the left column,
983 followed by word-wrapped HELP in a second column. */
985 wrap_help (const char *help
,
987 unsigned int item_width
,
988 unsigned int columns
)
990 unsigned int col_width
= LEFT_COLUMN
;
991 unsigned int remaining
, room
, len
;
993 remaining
= strlen (help
);
997 room
= columns
- 3 - MAX (col_width
, item_width
);
1006 for (i
= 0; help
[i
]; i
++)
1008 if (i
>= room
&& len
!= remaining
)
1012 else if ((help
[i
] == '-' || help
[i
] == '/')
1013 && help
[i
+ 1] != ' '
1014 && i
> 0 && ISALPHA (help
[i
- 1]))
1019 printf (" %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1021 while (help
[len
] == ' ')
1029 /* Print help for a specific front-end, etc. */
1031 print_filtered_help (unsigned int include_flags
,
1032 unsigned int exclude_flags
,
1033 unsigned int any_flags
,
1034 unsigned int columns
,
1035 struct gcc_options
*opts
,
1036 unsigned int lang_mask
)
1041 bool displayed
= false;
1044 if (include_flags
== CL_PARAMS
)
1046 for (i
= 0; i
< LAST_PARAM
; i
++)
1048 const char *param
= compiler_params
[i
].option
;
1050 help
= compiler_params
[i
].help
;
1051 if (help
== NULL
|| *help
== '\0')
1053 if (exclude_flags
& CL_UNDOCUMENTED
)
1055 help
= undocumented_msg
;
1058 /* Get the translation. */
1061 if (!opts
->x_quiet_flag
)
1063 snprintf (new_help
, sizeof (new_help
),
1064 _("default %d minimum %d maximum %d"),
1065 compiler_params
[i
].default_value
,
1066 compiler_params
[i
].min_value
,
1067 compiler_params
[i
].max_value
);
1070 wrap_help (help
, param
, strlen (param
), columns
);
1076 if (!opts
->x_help_printed
)
1077 opts
->x_help_printed
= XCNEWVAR (char, cl_options_count
);
1079 if (!opts
->x_help_enum_printed
)
1080 opts
->x_help_enum_printed
= XCNEWVAR (char, cl_enums_count
);
1082 for (i
= 0; i
< cl_options_count
; i
++)
1084 const struct cl_option
*option
= cl_options
+ i
;
1089 if (include_flags
== 0
1090 || ((option
->flags
& include_flags
) != include_flags
))
1092 if ((option
->flags
& any_flags
) == 0)
1096 /* Skip unwanted switches. */
1097 if ((option
->flags
& exclude_flags
) != 0)
1100 /* The driver currently prints its own help text. */
1101 if ((option
->flags
& CL_DRIVER
) != 0
1102 && (option
->flags
& (((1U << cl_lang_count
) - 1)
1103 | CL_COMMON
| CL_TARGET
)) == 0)
1107 /* Skip switches that have already been printed. */
1108 if (opts
->x_help_printed
[i
])
1111 opts
->x_help_printed
[i
] = true;
1113 help
= option
->help
;
1116 if (exclude_flags
& CL_UNDOCUMENTED
)
1119 help
= undocumented_msg
;
1122 if (option
->alias_target
< N_OPTS
1123 && cl_options
[option
->alias_target
].help
)
1125 if (help
== undocumented_msg
)
1127 /* For undocumented options that are aliases for other options
1128 that are documented, point the reader to the other option in
1129 preference of the former. */
1130 snprintf (new_help
, sizeof new_help
,
1131 _("Same as %s. Use the latter option instead."),
1132 cl_options
[option
->alias_target
].opt_text
);
1136 /* For documented options with aliases, mention the aliased
1137 option's name for reference. */
1138 snprintf (new_help
, sizeof new_help
,
1139 _("%s Same as %s."),
1140 help
, cl_options
[option
->alias_target
].opt_text
);
1146 if (option
->warn_message
)
1148 /* Mention that the use of the option will trigger a warning. */
1149 if (help
== new_help
)
1150 snprintf (new_help
+ strlen (new_help
),
1151 sizeof new_help
- strlen (new_help
),
1152 " %s", _(use_diagnosed_msg
));
1154 snprintf (new_help
, sizeof new_help
,
1155 "%s %s", help
, _(use_diagnosed_msg
));
1160 /* Get the translation. */
1163 /* Find the gap between the name of the
1164 option and its descriptive text. */
1165 tab
= strchr (help
, '\t');
1174 opt
= option
->opt_text
;
1178 /* With the -Q option enabled we change the descriptive text associated
1179 with an option to be an indication of its current setting. */
1180 if (!opts
->x_quiet_flag
)
1182 void *flag_var
= option_flag_var (i
, opts
);
1184 if (len
< (LEFT_COLUMN
+ 2))
1185 strcpy (new_help
, "\t\t");
1187 strcpy (new_help
, "\t");
1189 if (flag_var
!= NULL
1190 && option
->var_type
!= CLVC_DEFER
)
1192 if (option
->flags
& CL_JOINED
)
1194 if (option
->var_type
== CLVC_STRING
)
1196 if (* (const char **) flag_var
!= NULL
)
1197 snprintf (new_help
+ strlen (new_help
),
1198 sizeof (new_help
) - strlen (new_help
),
1199 "%s", * (const char **) flag_var
);
1201 else if (option
->var_type
== CLVC_ENUM
)
1203 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1205 const char *arg
= NULL
;
1207 value
= e
->get (flag_var
);
1208 enum_value_to_arg (e
->values
, &arg
, value
, lang_mask
);
1210 arg
= _("[default]");
1211 snprintf (new_help
+ strlen (new_help
),
1212 sizeof (new_help
) - strlen (new_help
),
1216 sprintf (new_help
+ strlen (new_help
),
1217 "%#x", * (int *) flag_var
);
1220 strcat (new_help
, option_enabled (i
, opts
)
1221 ? _("[enabled]") : _("[disabled]"));
1227 wrap_help (help
, opt
, len
, columns
);
1230 if (option
->var_type
== CLVC_ENUM
1231 && opts
->x_help_enum_printed
[option
->var_enum
] != 2)
1232 opts
->x_help_enum_printed
[option
->var_enum
] = 1;
1237 unsigned int langs
= include_flags
& CL_LANG_ALL
;
1240 printf (_(" No options with the desired characteristics were found\n"));
1245 /* PR 31349: Tell the user how to see all of the
1246 options supported by a specific front end. */
1247 for (i
= 0; (1U << i
) < CL_LANG_ALL
; i
++)
1248 if ((1U << i
) & langs
)
1249 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1250 lang_names
[i
], lang_names
[i
]);
1254 else if (! displayed
)
1255 printf (_(" All options with the desired characteristics have already been displayed\n"));
1259 /* Print details of enumerated option arguments, if those
1260 enumerations have help text headings provided. If no help text
1261 is provided, presume that the possible values are listed in the
1262 help text for the relevant options. */
1263 for (i
= 0; i
< cl_enums_count
; i
++)
1265 unsigned int j
, pos
;
1267 if (opts
->x_help_enum_printed
[i
] != 1)
1269 if (cl_enums
[i
].help
== NULL
)
1271 printf (" %s\n ", _(cl_enums
[i
].help
));
1273 for (j
= 0; cl_enums
[i
].values
[j
].arg
!= NULL
; j
++)
1275 unsigned int len
= strlen (cl_enums
[i
].values
[j
].arg
);
1277 if (pos
> 4 && pos
+ 1 + len
<= columns
)
1279 printf (" %s", cl_enums
[i
].values
[j
].arg
);
1289 printf ("%s", cl_enums
[i
].values
[j
].arg
);
1294 opts
->x_help_enum_printed
[i
] = 2;
1298 /* Display help for a specified type of option.
1299 The options must have ALL of the INCLUDE_FLAGS set
1300 ANY of the flags in the ANY_FLAGS set
1301 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1302 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1304 print_specific_help (unsigned int include_flags
,
1305 unsigned int exclude_flags
,
1306 unsigned int any_flags
,
1307 struct gcc_options
*opts
,
1308 unsigned int lang_mask
)
1310 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1311 const char * description
= NULL
;
1312 const char * descrip_extra
= "";
1316 /* Sanity check: Make sure that we do not have more
1317 languages than we have bits available to enumerate them. */
1318 gcc_assert ((1U << cl_lang_count
) <= CL_MIN_OPTION_CLASS
);
1320 /* If we have not done so already, obtain
1321 the desired maximum width of the output. */
1322 if (opts
->x_help_columns
== 0)
1324 opts
->x_help_columns
= get_terminal_width ();
1325 if (opts
->x_help_columns
== INT_MAX
)
1326 /* Use a reasonable default. */
1327 opts
->x_help_columns
= 80;
1330 /* Decide upon the title for the options that we are going to display. */
1331 for (i
= 0, flag
= 1; flag
<= CL_MAX_OPTION_CLASS
; flag
<<= 1, i
++)
1333 switch (flag
& include_flags
)
1340 description
= _("The following options are target specific");
1343 description
= _("The following options control compiler warning messages");
1345 case CL_OPTIMIZATION
:
1346 description
= _("The following options control optimizations");
1349 description
= _("The following options are language-independent");
1352 description
= _("The --param option recognizes the following as parameters");
1355 if (i
>= cl_lang_count
)
1357 if (exclude_flags
& all_langs_mask
)
1358 description
= _("The following options are specific to just the language ");
1360 description
= _("The following options are supported by the language ");
1361 descrip_extra
= lang_names
[i
];
1366 if (description
== NULL
)
1370 if (include_flags
& CL_UNDOCUMENTED
)
1371 description
= _("The following options are not documented");
1372 else if (include_flags
& CL_SEPARATE
)
1373 description
= _("The following options take separate arguments");
1374 else if (include_flags
& CL_JOINED
)
1375 description
= _("The following options take joined arguments");
1378 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1385 if (any_flags
& all_langs_mask
)
1386 description
= _("The following options are language-related");
1388 description
= _("The following options are language-independent");
1392 printf ("%s%s:\n", description
, descrip_extra
);
1393 print_filtered_help (include_flags
, exclude_flags
, any_flags
,
1394 opts
->x_help_columns
, opts
, lang_mask
);
1397 /* Enable FDO-related flags. */
1400 enable_fdo_optimizations (struct gcc_options
*opts
,
1401 struct gcc_options
*opts_set
,
1404 if (!opts_set
->x_flag_branch_probabilities
)
1405 opts
->x_flag_branch_probabilities
= value
;
1406 if (!opts_set
->x_flag_profile_values
)
1407 opts
->x_flag_profile_values
= value
;
1408 if (!opts_set
->x_flag_unroll_loops
)
1409 opts
->x_flag_unroll_loops
= value
;
1410 if (!opts_set
->x_flag_peel_loops
)
1411 opts
->x_flag_peel_loops
= value
;
1412 if (!opts_set
->x_flag_tracer
)
1413 opts
->x_flag_tracer
= value
;
1414 if (!opts_set
->x_flag_value_profile_transformations
)
1415 opts
->x_flag_value_profile_transformations
= value
;
1416 if (!opts_set
->x_flag_inline_functions
)
1417 opts
->x_flag_inline_functions
= value
;
1418 if (!opts_set
->x_flag_ipa_cp
)
1419 opts
->x_flag_ipa_cp
= value
;
1420 if (!opts_set
->x_flag_ipa_cp_clone
1421 && value
&& opts
->x_flag_ipa_cp
)
1422 opts
->x_flag_ipa_cp_clone
= value
;
1423 if (!opts_set
->x_flag_ipa_cp_alignment
1424 && value
&& opts
->x_flag_ipa_cp
)
1425 opts
->x_flag_ipa_cp_alignment
= value
;
1426 if (!opts_set
->x_flag_ipa_bit_cp
1427 && value
&& opts
->x_flag_ipa_cp
)
1428 opts
->x_flag_ipa_bit_cp
= value
;
1429 if (!opts_set
->x_flag_predictive_commoning
)
1430 opts
->x_flag_predictive_commoning
= value
;
1431 if (!opts_set
->x_flag_unswitch_loops
)
1432 opts
->x_flag_unswitch_loops
= value
;
1433 if (!opts_set
->x_flag_gcse_after_reload
)
1434 opts
->x_flag_gcse_after_reload
= value
;
1435 if (!opts_set
->x_flag_tree_loop_vectorize
1436 && !opts_set
->x_flag_tree_vectorize
)
1437 opts
->x_flag_tree_loop_vectorize
= value
;
1438 if (!opts_set
->x_flag_tree_slp_vectorize
1439 && !opts_set
->x_flag_tree_vectorize
)
1440 opts
->x_flag_tree_slp_vectorize
= value
;
1441 if (!opts_set
->x_flag_vect_cost_model
)
1442 opts
->x_flag_vect_cost_model
= VECT_COST_MODEL_DYNAMIC
;
1443 if (!opts_set
->x_flag_tree_loop_distribute_patterns
)
1444 opts
->x_flag_tree_loop_distribute_patterns
= value
;
1447 /* -f{,no-}sanitize{,-recover}= suboptions. */
1448 const struct sanitizer_opts_s sanitizer_opts
[] =
1450 #define SANITIZER_OPT(name, flags) { #name, flags, sizeof #name - 1 }
1451 SANITIZER_OPT (address
, SANITIZE_ADDRESS
| SANITIZE_USER_ADDRESS
),
1452 SANITIZER_OPT (kernel
-address
, SANITIZE_ADDRESS
| SANITIZE_KERNEL_ADDRESS
),
1453 SANITIZER_OPT (thread
, SANITIZE_THREAD
),
1454 SANITIZER_OPT (leak
, SANITIZE_LEAK
),
1455 SANITIZER_OPT (shift
, SANITIZE_SHIFT
),
1456 SANITIZER_OPT (integer
-divide
-by
-zero
, SANITIZE_DIVIDE
),
1457 SANITIZER_OPT (undefined
, SANITIZE_UNDEFINED
),
1458 SANITIZER_OPT (unreachable
, SANITIZE_UNREACHABLE
),
1459 SANITIZER_OPT (vla
-bound
, SANITIZE_VLA
),
1460 SANITIZER_OPT (return, SANITIZE_RETURN
),
1461 SANITIZER_OPT (null
, SANITIZE_NULL
),
1462 SANITIZER_OPT (signed-integer
-overflow
, SANITIZE_SI_OVERFLOW
),
1463 SANITIZER_OPT (bool, SANITIZE_BOOL
),
1464 SANITIZER_OPT (enum, SANITIZE_ENUM
),
1465 SANITIZER_OPT (float-divide
-by
-zero
, SANITIZE_FLOAT_DIVIDE
),
1466 SANITIZER_OPT (float-cast
-overflow
, SANITIZE_FLOAT_CAST
),
1467 SANITIZER_OPT (bounds
, SANITIZE_BOUNDS
),
1468 SANITIZER_OPT (bounds
-strict
, SANITIZE_BOUNDS
| SANITIZE_BOUNDS_STRICT
),
1469 SANITIZER_OPT (alignment
, SANITIZE_ALIGNMENT
),
1470 SANITIZER_OPT (nonnull
-attribute
, SANITIZE_NONNULL_ATTRIBUTE
),
1471 SANITIZER_OPT (returns
-nonnull
-attribute
, SANITIZE_RETURNS_NONNULL_ATTRIBUTE
),
1472 SANITIZER_OPT (object
-size
, SANITIZE_OBJECT_SIZE
),
1473 SANITIZER_OPT (vptr
, SANITIZE_VPTR
),
1474 SANITIZER_OPT (all
, ~0U),
1475 #undef SANITIZER_OPT
1479 /* Parse comma separated sanitizer suboptions from P for option SCODE,
1480 adjust previous FLAGS and return new ones. If COMPLAIN is false,
1481 don't issue diagnostics. */
1484 parse_sanitizer_options (const char *p
, location_t loc
, int scode
,
1485 unsigned int flags
, int value
, bool complain
)
1487 enum opt_code code
= (enum opt_code
) scode
;
1492 const char *comma
= strchr (p
, ',');
1504 /* Check to see if the string matches an option class name. */
1505 for (i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
1506 if (len
== sanitizer_opts
[i
].len
1507 && memcmp (p
, sanitizer_opts
[i
].name
, len
) == 0)
1509 /* Handle both -fsanitize and -fno-sanitize cases. */
1510 if (value
&& sanitizer_opts
[i
].flag
== ~0U)
1512 if (code
== OPT_fsanitize_
)
1515 error_at (loc
, "-fsanitize=all option is not valid");
1518 flags
|= ~(SANITIZE_USER_ADDRESS
| SANITIZE_THREAD
1522 flags
|= sanitizer_opts
[i
].flag
;
1524 flags
&= ~sanitizer_opts
[i
].flag
;
1529 if (! found
&& complain
)
1530 error_at (loc
, "unrecognized argument to -fsanitize%s= option: %q.*s",
1531 code
== OPT_fsanitize_
? "" : "-recover", (int) len
, p
);
1540 /* Handle target- and language-independent options. Return zero to
1541 generate an "unknown option" message. Only options that need
1542 extra handling need to be listed here; if you simply want
1543 DECODED->value assigned to a variable, it happens automatically. */
1546 common_handle_option (struct gcc_options
*opts
,
1547 struct gcc_options
*opts_set
,
1548 const struct cl_decoded_option
*decoded
,
1549 unsigned int lang_mask
, int kind ATTRIBUTE_UNUSED
,
1551 const struct cl_option_handlers
*handlers
,
1552 diagnostic_context
*dc
)
1554 size_t scode
= decoded
->opt_index
;
1555 const char *arg
= decoded
->arg
;
1556 int value
= decoded
->value
;
1557 enum opt_code code
= (enum opt_code
) scode
;
1559 gcc_assert (decoded
->canonical_option_num_elements
<= 2);
1564 handle_param (opts
, opts_set
, loc
, arg
);
1569 unsigned int all_langs_mask
= (1U << cl_lang_count
) - 1;
1570 unsigned int undoc_mask
;
1573 if (lang_mask
== CL_DRIVER
)
1576 undoc_mask
= ((opts
->x_verbose_flag
| opts
->x_extra_warnings
)
1579 /* First display any single language specific options. */
1580 for (i
= 0; i
< cl_lang_count
; i
++)
1582 (1U << i
, (all_langs_mask
& (~ (1U << i
))) | undoc_mask
, 0, opts
,
1584 /* Next display any multi language specific options. */
1585 print_specific_help (0, undoc_mask
, all_langs_mask
, opts
, lang_mask
);
1586 /* Then display any remaining, non-language options. */
1587 for (i
= CL_MIN_OPTION_CLASS
; i
<= CL_MAX_OPTION_CLASS
; i
<<= 1)
1589 print_specific_help (i
, undoc_mask
, 0, opts
, lang_mask
);
1590 opts
->x_exit_after_options
= true;
1594 case OPT__target_help
:
1595 if (lang_mask
== CL_DRIVER
)
1598 print_specific_help (CL_TARGET
, CL_UNDOCUMENTED
, 0, opts
, lang_mask
);
1599 opts
->x_exit_after_options
= true;
1604 const char *a
= arg
;
1605 unsigned int include_flags
= 0;
1606 /* Note - by default we include undocumented options when listing
1607 specific classes. If you only want to see documented options
1608 then add ",^undocumented" to the --help= option. E.g.:
1610 --help=target,^undocumented */
1611 unsigned int exclude_flags
= 0;
1613 if (lang_mask
== CL_DRIVER
)
1616 /* Walk along the argument string, parsing each word in turn.
1618 arg = [^]{word}[,{arg}]
1619 word = {optimizers|target|warnings|undocumented|
1620 params|common|<language>} */
1630 { "optimizers", CL_OPTIMIZATION
},
1631 { "target", CL_TARGET
},
1632 { "warnings", CL_WARNING
},
1633 { "undocumented", CL_UNDOCUMENTED
},
1634 { "params", CL_PARAMS
},
1635 { "joined", CL_JOINED
},
1636 { "separate", CL_SEPARATE
},
1637 { "common", CL_COMMON
},
1640 unsigned int *pflags
;
1642 unsigned int lang_flag
, specific_flag
;
1651 error_at (loc
, "missing argument to %qs", "--help=^");
1654 pflags
= &exclude_flags
;
1657 pflags
= &include_flags
;
1659 comma
= strchr (a
, ',');
1670 /* Check to see if the string matches an option class name. */
1671 for (i
= 0, specific_flag
= 0; specifics
[i
].string
!= NULL
; i
++)
1672 if (strncasecmp (a
, specifics
[i
].string
, len
) == 0)
1674 specific_flag
= specifics
[i
].flag
;
1678 /* Check to see if the string matches a language name.
1679 Note - we rely upon the alpha-sorted nature of the entries in
1680 the lang_names array, specifically that shorter names appear
1681 before their longer variants. (i.e. C before C++). That way
1682 when we are attempting to match --help=c for example we will
1683 match with C first and not C++. */
1684 for (i
= 0, lang_flag
= 0; i
< cl_lang_count
; i
++)
1685 if (strncasecmp (a
, lang_names
[i
], len
) == 0)
1687 lang_flag
= 1U << i
;
1691 if (specific_flag
!= 0)
1694 *pflags
|= specific_flag
;
1697 /* The option's argument matches both the start of a
1698 language name and the start of an option class name.
1699 We have a special case for when the user has
1700 specified "--help=c", but otherwise we have to issue
1702 if (strncasecmp (a
, "c", len
) == 0)
1703 *pflags
|= lang_flag
;
1706 "--help argument %q.*s is ambiguous, "
1707 "please be more specific",
1711 else if (lang_flag
!= 0)
1712 *pflags
|= lang_flag
;
1715 "unrecognized argument to --help= option: %q.*s",
1724 print_specific_help (include_flags
, exclude_flags
, 0, opts
,
1726 opts
->x_exit_after_options
= true;
1731 if (lang_mask
== CL_DRIVER
)
1734 opts
->x_exit_after_options
= true;
1737 case OPT_fsanitize_
:
1738 opts
->x_flag_sanitize
1739 = parse_sanitizer_options (arg
, loc
, code
,
1740 opts
->x_flag_sanitize
, value
, true);
1742 /* Kernel ASan implies normal ASan but does not yet support
1744 if (opts
->x_flag_sanitize
& SANITIZE_KERNEL_ADDRESS
)
1746 maybe_set_param_value (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD
,
1747 0, opts
->x_param_values
,
1748 opts_set
->x_param_values
);
1749 maybe_set_param_value (PARAM_ASAN_GLOBALS
, 0, opts
->x_param_values
,
1750 opts_set
->x_param_values
);
1751 maybe_set_param_value (PARAM_ASAN_STACK
, 0, opts
->x_param_values
,
1752 opts_set
->x_param_values
);
1753 maybe_set_param_value (PARAM_ASAN_USE_AFTER_RETURN
, 0,
1754 opts
->x_param_values
,
1755 opts_set
->x_param_values
);
1759 case OPT_fsanitize_recover_
:
1760 opts
->x_flag_sanitize_recover
1761 = parse_sanitizer_options (arg
, loc
, code
,
1762 opts
->x_flag_sanitize_recover
, value
, true);
1765 case OPT_fasan_shadow_offset_
:
1769 case OPT_fsanitize_recover
:
1771 opts
->x_flag_sanitize_recover
1772 |= SANITIZE_UNDEFINED
| SANITIZE_NONDEFAULT
;
1774 opts
->x_flag_sanitize_recover
1775 &= ~(SANITIZE_UNDEFINED
| SANITIZE_NONDEFAULT
);
1782 /* Currently handled in a prescan. */
1786 dc
->warning_as_error_requested
= value
;
1790 if (lang_mask
== CL_DRIVER
)
1793 enable_warning_as_error (arg
, value
, lang_mask
, handlers
,
1794 opts
, opts_set
, loc
, dc
);
1797 case OPT_Wlarger_than_
:
1798 opts
->x_larger_than_size
= value
;
1799 opts
->x_warn_larger_than
= value
!= -1;
1802 case OPT_Wfatal_errors
:
1803 dc
->fatal_errors
= value
;
1806 case OPT_Wframe_larger_than_
:
1807 opts
->x_frame_larger_than_size
= value
;
1808 opts
->x_warn_frame_larger_than
= value
!= -1;
1811 case OPT_Wstack_usage_
:
1812 opts
->x_warn_stack_usage
= value
;
1813 opts
->x_flag_stack_usage_info
= value
!= -1;
1816 case OPT_Wstrict_aliasing
:
1817 set_Wstrict_aliasing (opts
, value
);
1820 case OPT_Wstrict_overflow
:
1821 opts
->x_warn_strict_overflow
= (value
1822 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1826 case OPT_Wsystem_headers
:
1827 dc
->dc_warn_system_headers
= value
;
1831 opts
->x_flag_gen_aux_info
= 1;
1834 case OPT_auxbase_strip
:
1836 char *tmp
= xstrdup (arg
);
1837 strip_off_ending (tmp
, strlen (tmp
));
1839 opts
->x_aux_base_name
= tmp
;
1846 decode_d_option (arg
, opts
, loc
, dc
);
1849 case OPT_fcall_used_
:
1850 case OPT_fcall_saved_
:
1858 case OPT_fdbg_cnt_list
:
1860 opts
->x_exit_after_options
= true;
1863 case OPT_fdebug_prefix_map_
:
1867 case OPT_fdiagnostics_show_location_
:
1868 diagnostic_prefixing_rule (dc
) = (diagnostic_prefixing_rule_t
) value
;
1871 case OPT_fdiagnostics_show_caret
:
1872 dc
->show_caret
= value
;
1875 case OPT_fdiagnostics_color_
:
1876 diagnostic_color_init (dc
, value
);
1879 case OPT_fdiagnostics_parseable_fixits
:
1880 dc
->parseable_fixits_p
= value
;
1883 case OPT_fdiagnostics_show_option
:
1884 dc
->show_option_requested
= value
;
1891 case OPT_ffast_math
:
1892 set_fast_math_flags (opts
, value
);
1895 case OPT_funsafe_math_optimizations
:
1896 set_unsafe_math_optimizations_flags (opts
, value
);
1903 case OPT_finline_limit_
:
1904 set_param_value ("max-inline-insns-single", value
/ 2,
1905 opts
->x_param_values
, opts_set
->x_param_values
);
1906 set_param_value ("max-inline-insns-auto", value
/ 2,
1907 opts
->x_param_values
, opts_set
->x_param_values
);
1910 case OPT_finstrument_functions_exclude_function_list_
:
1911 add_comma_separated_to_vector
1912 (&opts
->x_flag_instrument_functions_exclude_functions
, arg
);
1915 case OPT_finstrument_functions_exclude_file_list_
:
1916 add_comma_separated_to_vector
1917 (&opts
->x_flag_instrument_functions_exclude_files
, arg
);
1920 case OPT_fmessage_length_
:
1921 pp_set_line_maximum_length (dc
->printer
, value
);
1922 diagnostic_set_caret_max_width (dc
, value
);
1926 case OPT_fopt_info_
:
1932 const char *p
= arg
;
1933 opts
->x_flag_disable_hsa
= true;
1936 const char *comma
= strchr (p
, ',');
1938 if ((strncmp (p
, "disable", 7) == 0)
1939 && (p
[7] == ',' || p
[7] == '\0'))
1941 opts
->x_flag_disable_hsa
= true;
1945 if ((strncmp (p
, "hsa", 3) == 0)
1946 && (p
[3] == ',' || p
[3] == '\0'))
1949 opts
->x_flag_disable_hsa
= false;
1951 sorry ("HSA has not been enabled during configuration");
1961 #ifndef ACCEL_COMPILER
1962 case OPT_foffload_abi_
:
1963 error_at (loc
, "-foffload-abi option can be specified only for "
1964 "offload compiler");
1968 case OPT_fpack_struct_
:
1969 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
1971 "structure alignment must be a small power of two, not %d",
1974 opts
->x_initial_max_fld_align
= value
;
1978 case OPT_fplugin_arg_
:
1982 case OPT_fprofile_use_
:
1983 opts
->x_profile_data_prefix
= xstrdup (arg
);
1984 opts
->x_flag_profile_use
= true;
1986 /* No break here - do -fprofile-use processing. */
1988 case OPT_fprofile_use
:
1989 enable_fdo_optimizations (opts
, opts_set
, value
);
1990 if (!opts_set
->x_flag_profile_reorder_functions
)
1991 opts
->x_flag_profile_reorder_functions
= value
;
1992 /* Indirect call profiling should do all useful transformations
1993 speculative devirtualization does. */
1994 if (!opts_set
->x_flag_devirtualize_speculatively
1995 && opts
->x_flag_value_profile_transformations
)
1996 opts
->x_flag_devirtualize_speculatively
= false;
1999 case OPT_fauto_profile_
:
2000 opts
->x_auto_profile_file
= xstrdup (arg
);
2001 opts
->x_flag_auto_profile
= true;
2003 /* No break here - do -fauto-profile processing. */
2005 case OPT_fauto_profile
:
2006 enable_fdo_optimizations (opts
, opts_set
, value
);
2007 if (!opts_set
->x_flag_profile_correction
)
2008 opts
->x_flag_profile_correction
= value
;
2009 maybe_set_param_value (
2010 PARAM_EARLY_INLINER_MAX_ITERATIONS
, 10,
2011 opts
->x_param_values
, opts_set
->x_param_values
);
2014 case OPT_fprofile_generate_
:
2015 opts
->x_profile_data_prefix
= xstrdup (arg
);
2017 /* No break here - do -fprofile-generate processing. */
2019 case OPT_fprofile_generate
:
2020 if (!opts_set
->x_profile_arc_flag
)
2021 opts
->x_profile_arc_flag
= value
;
2022 if (!opts_set
->x_flag_profile_values
)
2023 opts
->x_flag_profile_values
= value
;
2024 if (!opts_set
->x_flag_inline_functions
)
2025 opts
->x_flag_inline_functions
= value
;
2026 /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
2027 quadratic. Disable the pass until better memory representation
2029 if (!opts_set
->x_flag_ipa_reference
)
2030 opts
->x_flag_ipa_reference
= false;
2033 case OPT_ftree_vectorize
:
2034 if (!opts_set
->x_flag_tree_loop_vectorize
)
2035 opts
->x_flag_tree_loop_vectorize
= value
;
2036 if (!opts_set
->x_flag_tree_slp_vectorize
)
2037 opts
->x_flag_tree_slp_vectorize
= value
;
2039 case OPT_fshow_column
:
2040 dc
->show_column
= value
;
2043 case OPT_frandom_seed
:
2044 /* The real switch is -fno-random-seed. */
2050 case OPT_frandom_seed_
:
2054 case OPT_fsched_verbose_
:
2055 #ifdef INSN_SCHEDULING
2056 /* Handled with Var in common.opt. */
2062 case OPT_fsched_stalled_insns_
:
2063 opts
->x_flag_sched_stalled_insns
= value
;
2064 if (opts
->x_flag_sched_stalled_insns
== 0)
2065 opts
->x_flag_sched_stalled_insns
= -1;
2068 case OPT_fsched_stalled_insns_dep_
:
2069 opts
->x_flag_sched_stalled_insns_dep
= value
;
2072 case OPT_fstack_check_
:
2073 if (!strcmp (arg
, "no"))
2074 opts
->x_flag_stack_check
= NO_STACK_CHECK
;
2075 else if (!strcmp (arg
, "generic"))
2076 /* This is the old stack checking method. */
2077 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2078 ? FULL_BUILTIN_STACK_CHECK
2079 : GENERIC_STACK_CHECK
;
2080 else if (!strcmp (arg
, "specific"))
2081 /* This is the new stack checking method. */
2082 opts
->x_flag_stack_check
= STACK_CHECK_BUILTIN
2083 ? FULL_BUILTIN_STACK_CHECK
2084 : STACK_CHECK_STATIC_BUILTIN
2085 ? STATIC_BUILTIN_STACK_CHECK
2086 : GENERIC_STACK_CHECK
;
2088 warning_at (loc
, 0, "unknown stack check parameter %qs", arg
);
2091 case OPT_fstack_limit
:
2092 /* The real switch is -fno-stack-limit. */
2098 case OPT_fstack_limit_register_
:
2099 case OPT_fstack_limit_symbol_
:
2103 case OPT_fstack_usage
:
2104 opts
->x_flag_stack_usage
= value
;
2105 opts
->x_flag_stack_usage_info
= value
!= 0;
2109 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
, opts
, opts_set
,
2114 set_debug_level (SDB_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2118 if (arg
&& strlen (arg
) != 0)
2120 error_at (loc
, "%<-gdwarf%s%> is ambiguous; "
2121 "use %<-gdwarf-%s%> for DWARF version "
2122 "or %<-gdwarf -g%s%> for debug level", arg
, arg
, arg
);
2126 value
= opts
->x_dwarf_version
;
2130 if (value
< 2 || value
> 5)
2131 error_at (loc
, "dwarf version %d is not supported", value
);
2133 opts
->x_dwarf_version
= value
;
2134 set_debug_level (DWARF2_DEBUG
, false, "", opts
, opts_set
, loc
);
2137 case OPT_gsplit_dwarf
:
2138 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, "", opts
, opts_set
,
2143 set_debug_level (NO_DEBUG
, 2, arg
, opts
, opts_set
, loc
);
2148 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
, opts
, opts_set
,
2153 set_debug_level (VMS_DEBUG
, false, arg
, opts
, opts_set
, loc
);
2158 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
, opts
, opts_set
,
2164 /* Handled completely via specs. */
2167 case OPT_pedantic_errors
:
2168 dc
->pedantic_errors
= 1;
2169 control_warning_option (OPT_Wpedantic
, DK_ERROR
, NULL
, value
,
2171 handlers
, opts
, opts_set
,
2176 opts
->x_flag_lto
= value
? "" : NULL
;
2180 dc
->dc_inhibit_warnings
= true;
2183 case OPT_fmax_errors_
:
2184 dc
->max_errors
= value
;
2187 case OPT_fuse_ld_bfd
:
2188 case OPT_fuse_ld_gold
:
2189 case OPT_fuse_linker_plugin
:
2190 /* No-op. Used by the driver and passed to us because it starts with f.*/
2195 opts
->x_flag_trapv
= 0;
2200 opts
->x_flag_wrapv
= 0;
2204 opts
->x_flag_ipa_icf_functions
= value
;
2205 opts
->x_flag_ipa_icf_variables
= value
;
2209 /* If the flag was handled in a standard way, assume the lack of
2210 processing here is intentional. */
2211 gcc_assert (option_flag_var (scode
, opts
));
2215 common_handle_option_auto (opts
, opts_set
, decoded
, lang_mask
, kind
,
2220 /* Handle --param NAME=VALUE. */
2222 handle_param (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2223 location_t loc
, const char *carg
)
2228 arg
= xstrdup (carg
);
2229 equal
= strchr (arg
, '=');
2231 error_at (loc
, "%s: --param arguments should be of the form NAME=VALUE",
2237 enum compiler_param index
;
2238 if (!find_param (arg
, &index
))
2240 const char *suggestion
= find_param_fuzzy (arg
);
2242 error_at (loc
, "invalid --param name %qs; did you mean %qs?",
2245 error_at (loc
, "invalid --param name %qs", arg
);
2249 if (!param_string_value_p (index
, equal
+ 1, &value
))
2250 value
= integral_argument (equal
+ 1);
2253 error_at (loc
, "invalid --param value %qs", equal
+ 1);
2255 set_param_value (arg
, value
,
2256 opts
->x_param_values
, opts_set
->x_param_values
);
2263 /* Used to set the level of strict aliasing warnings in OPTS,
2264 when no level is specified (i.e., when -Wstrict-aliasing, and not
2265 -Wstrict-aliasing=level was given).
2266 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2267 and 0 otherwise. After calling this function, wstrict_aliasing will be
2268 set to the default value of -Wstrict_aliasing=level, currently 3. */
2270 set_Wstrict_aliasing (struct gcc_options
*opts
, int onoff
)
2272 gcc_assert (onoff
== 0 || onoff
== 1);
2274 opts
->x_warn_strict_aliasing
= 3;
2276 opts
->x_warn_strict_aliasing
= 0;
2279 /* The following routines are useful in setting all the flags that
2280 -ffast-math and -fno-fast-math imply. */
2282 set_fast_math_flags (struct gcc_options
*opts
, int set
)
2284 if (!opts
->frontend_set_flag_unsafe_math_optimizations
)
2286 opts
->x_flag_unsafe_math_optimizations
= set
;
2287 set_unsafe_math_optimizations_flags (opts
, set
);
2289 if (!opts
->frontend_set_flag_finite_math_only
)
2290 opts
->x_flag_finite_math_only
= set
;
2291 if (!opts
->frontend_set_flag_errno_math
)
2292 opts
->x_flag_errno_math
= !set
;
2295 if (!opts
->frontend_set_flag_signaling_nans
)
2296 opts
->x_flag_signaling_nans
= 0;
2297 if (!opts
->frontend_set_flag_rounding_math
)
2298 opts
->x_flag_rounding_math
= 0;
2299 if (!opts
->frontend_set_flag_cx_limited_range
)
2300 opts
->x_flag_cx_limited_range
= 1;
2304 /* When -funsafe-math-optimizations is set the following
2305 flags are set as well. */
2307 set_unsafe_math_optimizations_flags (struct gcc_options
*opts
, int set
)
2309 if (!opts
->frontend_set_flag_trapping_math
)
2310 opts
->x_flag_trapping_math
= !set
;
2311 if (!opts
->frontend_set_flag_signed_zeros
)
2312 opts
->x_flag_signed_zeros
= !set
;
2313 if (!opts
->frontend_set_flag_associative_math
)
2314 opts
->x_flag_associative_math
= set
;
2315 if (!opts
->frontend_set_flag_reciprocal_math
)
2316 opts
->x_flag_reciprocal_math
= set
;
2319 /* Return true iff flags in OPTS are set as if -ffast-math. */
2321 fast_math_flags_set_p (const struct gcc_options
*opts
)
2323 return (!opts
->x_flag_trapping_math
2324 && opts
->x_flag_unsafe_math_optimizations
2325 && opts
->x_flag_finite_math_only
2326 && !opts
->x_flag_signed_zeros
2327 && !opts
->x_flag_errno_math
);
2330 /* Return true iff flags are set as if -ffast-math but using the flags stored
2331 in the struct cl_optimization structure. */
2333 fast_math_flags_struct_set_p (struct cl_optimization
*opt
)
2335 return (!opt
->x_flag_trapping_math
2336 && opt
->x_flag_unsafe_math_optimizations
2337 && opt
->x_flag_finite_math_only
2338 && !opt
->x_flag_signed_zeros
2339 && !opt
->x_flag_errno_math
);
2342 /* Handle a debug output -g switch for options OPTS
2343 (OPTS_SET->x_write_symbols storing whether a debug type was passed
2344 explicitly), location LOC. EXTENDED is true or false to support
2345 extended output (2 is special and means "-ggdb" was given). */
2347 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
,
2348 struct gcc_options
*opts
, struct gcc_options
*opts_set
,
2351 opts
->x_use_gnu_debug_info_extensions
= extended
;
2353 if (type
== NO_DEBUG
)
2355 if (opts
->x_write_symbols
== NO_DEBUG
)
2357 opts
->x_write_symbols
= PREFERRED_DEBUGGING_TYPE
;
2361 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
2362 opts
->x_write_symbols
= DWARF2_DEBUG
;
2363 #elif defined DBX_DEBUGGING_INFO
2364 opts
->x_write_symbols
= DBX_DEBUG
;
2368 if (opts
->x_write_symbols
== NO_DEBUG
)
2369 warning_at (loc
, 0, "target system does not support debug output");
2374 /* Does it conflict with an already selected type? */
2375 if (opts_set
->x_write_symbols
!= NO_DEBUG
2376 && opts
->x_write_symbols
!= NO_DEBUG
2377 && type
!= opts
->x_write_symbols
)
2378 error_at (loc
, "debug format %qs conflicts with prior selection",
2379 debug_type_names
[type
]);
2380 opts
->x_write_symbols
= type
;
2381 opts_set
->x_write_symbols
= type
;
2384 /* A debug flag without a level defaults to level 2.
2385 If off or at level 1, set it to level 2, but if already
2386 at level 3, don't lower it. */
2389 if (opts
->x_debug_info_level
< DINFO_LEVEL_NORMAL
)
2390 opts
->x_debug_info_level
= DINFO_LEVEL_NORMAL
;
2394 int argval
= integral_argument (arg
);
2396 error_at (loc
, "unrecognised debug output level %qs", arg
);
2397 else if (argval
> 3)
2398 error_at (loc
, "debug output level %qs is too high", arg
);
2400 opts
->x_debug_info_level
= (enum debug_info_levels
) argval
;
2404 /* Arrange to dump core on error for diagnostic context DC. (The
2405 regular error message is still printed first, except in the case of
2409 setup_core_dumping (diagnostic_context
*dc
)
2412 signal (SIGABRT
, SIG_DFL
);
2414 #if defined(HAVE_SETRLIMIT)
2417 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
2418 fatal_error (input_location
, "getting core file size maximum limit: %m");
2419 rlim
.rlim_cur
= rlim
.rlim_max
;
2420 if (setrlimit (RLIMIT_CORE
, &rlim
) != 0)
2421 fatal_error (input_location
,
2422 "setting core file size limit to maximum: %m");
2425 diagnostic_abort_on_error (dc
);
2428 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
2429 diagnostic context DC. */
2432 decode_d_option (const char *arg
, struct gcc_options
*opts
,
2433 location_t loc
, diagnostic_context
*dc
)
2441 opts
->x_flag_debug_asm
= 1;
2444 opts
->x_flag_print_asm_name
= 1;
2447 opts
->x_flag_dump_rtl_in_asm
= 1;
2448 opts
->x_flag_print_asm_name
= 1;
2451 opts
->x_rtl_dump_and_exit
= 1;
2453 case 'D': /* These are handled by the preprocessor. */
2460 setup_core_dumping (dc
);
2463 opts
->x_flag_dump_all_passed
= true;
2467 warning_at (loc
, 0, "unrecognized gcc debugging option: %c", c
);
2472 /* Enable (or disable if VALUE is 0) a warning option ARG (language
2473 mask LANG_MASK, option handlers HANDLERS) as an error for option
2474 structures OPTS and OPTS_SET, diagnostic context DC (possibly
2475 NULL), location LOC. This is used by -Werror=. */
2478 enable_warning_as_error (const char *arg
, int value
, unsigned int lang_mask
,
2479 const struct cl_option_handlers
*handlers
,
2480 struct gcc_options
*opts
,
2481 struct gcc_options
*opts_set
,
2482 location_t loc
, diagnostic_context
*dc
)
2487 new_option
= XNEWVEC (char, strlen (arg
) + 2);
2488 new_option
[0] = 'W';
2489 strcpy (new_option
+ 1, arg
);
2490 option_index
= find_opt (new_option
, lang_mask
);
2491 if (option_index
== OPT_SPECIAL_unknown
)
2492 error_at (loc
, "-Werror=%s: no option -%s", arg
, new_option
);
2493 else if (!(cl_options
[option_index
].flags
& CL_WARNING
))
2494 error_at (loc
, "-Werror=%s: -%s is not an option that controls warnings",
2498 const diagnostic_t kind
= value
? DK_ERROR
: DK_WARNING
;
2499 const char *arg
= NULL
;
2501 if (cl_options
[option_index
].flags
& CL_JOINED
)
2502 arg
= new_option
+ cl_options
[option_index
].opt_len
;
2503 control_warning_option (option_index
, (int) kind
, arg
, value
,
2505 handlers
, opts
, opts_set
, dc
);
2510 /* Return malloced memory for the name of the option OPTION_INDEX
2511 which enabled a diagnostic (context CONTEXT), originally of type
2512 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2516 option_name (diagnostic_context
*context
, int option_index
,
2517 diagnostic_t orig_diag_kind
, diagnostic_t diag_kind
)
2521 /* A warning classified as an error. */
2522 if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
)
2523 && diag_kind
== DK_ERROR
)
2524 return concat (cl_options
[OPT_Werror_
].opt_text
,
2525 /* Skip over "-W". */
2526 cl_options
[option_index
].opt_text
+ 2,
2528 /* A warning with option. */
2530 return xstrdup (cl_options
[option_index
].opt_text
);
2532 /* A warning without option classified as an error. */
2533 else if ((orig_diag_kind
== DK_WARNING
|| orig_diag_kind
== DK_PEDWARN
2534 || diag_kind
== DK_WARNING
)
2535 && context
->warning_as_error_requested
)
2536 return xstrdup (cl_options
[OPT_Werror
].opt_text
);