1/* Command line option handling.
2 Copyright (C) 2002-2017 Free Software Foundation, Inc.
3 Contributed by Neil Booth.
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21#include "config.h"
22#include "system.h"
23#include "intl.h"
24#include "coretypes.h"
25#include "opts.h"
26#include "tm.h"
27#include "flags.h"
28#include "params.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"
34
35static void set_Wstrict_aliasing (struct gcc_options *opts, int onoff);
36
37/* Indexed by enum debug_info_type. */
38const char *const debug_type_names[] =
39{
40 "none", "stabs", "dwarf-2", "xcoff", "vms"
41};
42
43/* Parse the -femit-struct-debug-detailed option value
44 and set the flag variables. */
45
46#define MATCH( prefix, string ) \
47 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
48 ? ((string += sizeof prefix - 1), 1) : 0)
49
50void
51set_struct_debug_option (struct gcc_options *opts, location_t loc,
52 const char *spec)
53{
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";
59
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;
63 int ord = 1, gen = 1;
64
65 /* What usage? */
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;
72
73 /* Generics or not? */
74 if (MATCH (ord_lbl, spec))
75 gen = 0;
76 else if (MATCH (gen_lbl, spec))
77 ord = 0;
78
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;
88 else
89 error_at (loc,
90 "argument %qs to %<-femit-struct-debug-detailed%> "
91 "not recognized",
92 spec);
93
94 /* Effect the specification. */
95 if (usage == DINFO_USAGE_NUM_ENUMS)
96 {
97 if (ord)
98 {
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;
102 }
103 if (gen)
104 {
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;
108 }
109 }
110 else
111 {
112 if (ord)
113 opts->x_debug_struct_ordinary[usage] = files;
114 if (gen)
115 opts->x_debug_struct_generic[usage] = files;
116 }
117
118 if (*spec == ',')
119 set_struct_debug_option (opts, loc, spec+1);
120 else
121 {
122 /* No more -femit-struct-debug-detailed specifications.
123 Do final checks. */
124 if (*spec != '\0')
125 error_at (loc,
126 "argument %qs to %<-femit-struct-debug-detailed%> unknown",
127 spec);
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])
132 error_at (loc,
133 "%<-femit-struct-debug-detailed=dir:...%> must allow "
134 "at least as much as "
135 "%<-femit-struct-debug-detailed=ind:...%>");
136 }
137}
138
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".) */
143
144void
145strip_off_ending (char *name, int len)
146{
147 int i;
148 for (i = 2; i < 5 && len > i; i++)
149 {
150 if (name[len - i] == '.')
151 {
152 name[len - i] = '\0';
153 break;
154 }
155 }
156}
157
158/* Find the base name of a path, stripping off both directories and
159 a single final extension. */
160int
161base_of_path (const char *path, const char **base_out)
162{
163 const char *base = path;
164 const char *dot = 0;
165 const char *p = path;
166 char c = *p;
167 while (c)
168 {
169 if (IS_DIR_SEPARATOR (c))
170 {
171 base = p + 1;
172 dot = 0;
173 }
174 else if (c == '.')
175 dot = p;
176 c = *++p;
177 }
178 if (!dot)
179 dot = p;
180 *base_out = base;
181 return dot - base;
182}
183
184/* What to print when a switch has no documentation. */
185static const char undocumented_msg[] = N_("This option lacks documentation.");
186static const char use_diagnosed_msg[] = N_("Uses of this option are diagnosed.");
187
188typedef char *char_p; /* For DEF_VEC_P. */
189
190static void handle_param (struct gcc_options *opts,
191 struct gcc_options *opts_set, location_t loc,
192 const char *carg);
193static 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,
196 location_t loc);
197static void set_fast_math_flags (struct gcc_options *opts, int set);
198static void decode_d_option (const char *arg, struct gcc_options *opts,
199 location_t loc, diagnostic_context *dc);
200static void set_unsafe_math_optimizations_flags (struct gcc_options *opts,
201 int set);
202static 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,
207 location_t loc,
208 diagnostic_context *dc);
209
210/* Handle a back-end option; arguments and return value as for
211 handle_option. */
212
213bool
214target_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,
218 location_t loc,
219 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
220 diagnostic_context *dc, void (*) (void))
221{
222 gcc_assert (dc == global_dc);
223 gcc_assert (kind == DK_UNSPECIFIED);
224 return targetm_common.handle_option (opts, opts_set, decoded, loc);
225}
226
227/* Add comma-separated strings to a char_p vector. */
228
229static void
230add_comma_separated_to_vector (void **pvec, const char *arg)
231{
232 char *tmp;
233 char *r;
234 char *w;
235 char *token_start;
236 vec<char_p> *v = (vec<char_p> *) *pvec;
237
238 vec_check_alloc (v, 1);
239
240 /* We never free this string. */
241 tmp = xstrdup (arg);
242
243 r = tmp;
244 w = tmp;
245 token_start = tmp;
246
247 while (*r != '\0')
248 {
249 if (*r == ',')
250 {
251 *w++ = '\0';
252 ++r;
253 v->safe_push (token_start);
254 token_start = w;
255 }
256 if (*r == '\\' && r[1] == ',')
257 {
258 *w++ = ',';
259 r += 2;
260 }
261 else
262 *w++ = *r++;
263 }
264 if (*token_start != '\0')
265 v->safe_push (token_start);
266
267 *pvec = v;
268}
269
270/* Initialize opts_obstack. */
271
272void
273init_opts_obstack (void)
274{
275 gcc_obstack_init (&opts_obstack);
276}
277
278/* Initialize OPTS and OPTS_SET before using them in parsing options. */
279
280void
281init_options_struct (struct gcc_options *opts, struct gcc_options *opts_set)
282{
283 size_t num_params = get_num_compiler_params ();
284
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);
288
289 *opts = global_options_init;
290
291 if (opts_set)
292 memset (opts_set, 0, sizeof (*opts_set));
293
294 opts->x_param_values = XNEWVEC (int, num_params);
295
296 if (opts_set)
297 opts_set->x_param_values = XCNEWVEC (int, num_params);
298
299 init_param_values (opts->x_param_values);
300
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;
306
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;
310
311 /* Some targets have ABI-specified unwind tables. */
312 opts->x_flag_unwind_tables = targetm_common.unwind_tables_default;
313
314 /* Some targets have other target-specific initialization. */
315 targetm_common.option_init_struct (opts);
316}
317
318/* Release any allocations owned by OPTS. */
319
320void
321finalize_options_struct (struct gcc_options *opts)
322{
323 XDELETEVEC (opts->x_param_values);
324}
325
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. */
330
331static void
332maybe_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,
338 location_t loc,
339 diagnostic_context *dc)
340{
341 const struct cl_option *option = &cl_options[default_opt->opt_index];
342 bool enabled;
343
344 if (size)
345 gcc_assert (level == 2);
346 if (fast)
347 gcc_assert (level == 3);
348 if (debug)
349 gcc_assert (level == 1);
350
351 switch (default_opt->levels)
352 {
353 case OPT_LEVELS_ALL:
354 enabled = true;
355 break;
356
357 case OPT_LEVELS_0_ONLY:
358 enabled = (level == 0);
359 break;
360
361 case OPT_LEVELS_1_PLUS:
362 enabled = (level >= 1);
363 break;
364
365 case OPT_LEVELS_1_PLUS_SPEED_ONLY:
366 enabled = (level >= 1 && !size && !debug);
367 break;
368
369 case OPT_LEVELS_1_PLUS_NOT_DEBUG:
370 enabled = (level >= 1 && !debug);
371 break;
372
373 case OPT_LEVELS_2_PLUS:
374 enabled = (level >= 2);
375 break;
376
377 case OPT_LEVELS_2_PLUS_SPEED_ONLY:
378 enabled = (level >= 2 && !size && !debug);
379 break;
380
381 case OPT_LEVELS_3_PLUS:
382 enabled = (level >= 3);
383 break;
384
385 case OPT_LEVELS_3_PLUS_AND_SIZE:
386 enabled = (level >= 3 || size);
387 break;
388
389 case OPT_LEVELS_SIZE:
390 enabled = size;
391 break;
392
393 case OPT_LEVELS_FAST:
394 enabled = fast;
395 break;
396
397 case OPT_LEVELS_NONE:
398 default:
399 gcc_unreachable ();
400 }
401
402 if (enabled)
403 handle_generated_option (opts, opts_set, default_opt->opt_index,
404 default_opt->arg, default_opt->value,
405 lang_mask, DK_UNSPECIFIED, loc,
406 handlers, true, dc);
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,
412 handlers, true, dc);
413}
414
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. */
419
420static void
421maybe_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,
427 location_t loc,
428 diagnostic_context *dc)
429{
430 size_t i;
431
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);
436}
437
438/* Table of options enabled by default at different levels. */
439
440static const struct default_options default_options_table[] =
441 {
442 /* -O1 optimizations. */
443 { OPT_LEVELS_1_PLUS, OPT_fdefer_pop, NULL, 1 },
444#if DELAY_SLOTS
445 { OPT_LEVELS_1_PLUS, OPT_fdelayed_branch, NULL, 1 },
446#endif
447 { OPT_LEVELS_1_PLUS, OPT_fguess_branch_probability, NULL, 1 },
448 { OPT_LEVELS_1_PLUS, OPT_fcprop_registers, NULL, 1 },
449 { OPT_LEVELS_1_PLUS, OPT_fforward_propagate, NULL, 1 },
450 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fif_conversion, NULL, 1 },
451 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fif_conversion2, NULL, 1 },
452 { OPT_LEVELS_1_PLUS, OPT_fipa_pure_const, NULL, 1 },
453 { OPT_LEVELS_1_PLUS, OPT_fipa_reference, NULL, 1 },
454 { OPT_LEVELS_1_PLUS, OPT_fipa_profile, NULL, 1 },
455 { OPT_LEVELS_1_PLUS, OPT_fmerge_constants, NULL, 1 },
456 { OPT_LEVELS_1_PLUS, OPT_freorder_blocks, NULL, 1 },
457 { OPT_LEVELS_1_PLUS, OPT_fshrink_wrap, NULL, 1 },
458 { OPT_LEVELS_1_PLUS, OPT_fsplit_wide_types, NULL, 1 },
459 { OPT_LEVELS_1_PLUS, OPT_ftree_ccp, NULL, 1 },
460 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_bit_ccp, NULL, 1 },
461 { OPT_LEVELS_1_PLUS, OPT_ftree_coalesce_vars, NULL, 1 },
462 { OPT_LEVELS_1_PLUS, OPT_ftree_dce, NULL, 1 },
463 { OPT_LEVELS_1_PLUS, OPT_ftree_dominator_opts, NULL, 1 },
464 { OPT_LEVELS_1_PLUS, OPT_ftree_dse, NULL, 1 },
465 { OPT_LEVELS_1_PLUS, OPT_ftree_ter, NULL, 1 },
466 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_sra, NULL, 1 },
467 { OPT_LEVELS_1_PLUS, OPT_ftree_fre, NULL, 1 },
468 { OPT_LEVELS_1_PLUS, OPT_ftree_copy_prop, NULL, 1 },
469 { OPT_LEVELS_1_PLUS, OPT_ftree_sink, NULL, 1 },
470 { OPT_LEVELS_1_PLUS, OPT_ftree_ch, NULL, 1 },
471 { OPT_LEVELS_1_PLUS, OPT_fcombine_stack_adjustments, NULL, 1 },
472 { OPT_LEVELS_1_PLUS, OPT_fcompare_elim, NULL, 1 },
473 { OPT_LEVELS_1_PLUS, OPT_ftree_slsr, NULL, 1 },
474 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fbranch_count_reg, NULL, 1 },
475 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fmove_loop_invariants, NULL, 1 },
476 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_pta, NULL, 1 },
477 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fssa_phiopt, NULL, 1 },
478 { OPT_LEVELS_1_PLUS, OPT_ftree_builtin_call_dce, NULL, 1 },
479 { OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
480
481 /* -O2 optimizations. */
482 { OPT_LEVELS_2_PLUS, OPT_finline_small_functions, NULL, 1 },
483 { OPT_LEVELS_2_PLUS, OPT_findirect_inlining, NULL, 1 },
484 { OPT_LEVELS_2_PLUS, OPT_fpartial_inlining, NULL, 1 },
485 { OPT_LEVELS_2_PLUS, OPT_fthread_jumps, NULL, 1 },
486 { OPT_LEVELS_2_PLUS, OPT_fcrossjumping, NULL, 1 },
487 { OPT_LEVELS_2_PLUS, OPT_foptimize_sibling_calls, NULL, 1 },
488 { OPT_LEVELS_2_PLUS, OPT_fcse_follow_jumps, NULL, 1 },
489 { OPT_LEVELS_2_PLUS, OPT_fgcse, NULL, 1 },
490 { OPT_LEVELS_2_PLUS, OPT_fexpensive_optimizations, NULL, 1 },
491 { OPT_LEVELS_2_PLUS, OPT_frerun_cse_after_loop, NULL, 1 },
492 { OPT_LEVELS_2_PLUS, OPT_fcaller_saves, NULL, 1 },
493 { OPT_LEVELS_2_PLUS, OPT_fpeephole2, NULL, 1 },
494#ifdef INSN_SCHEDULING
495 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
496 { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_fschedule_insns, NULL, 1 },
497 { OPT_LEVELS_2_PLUS, OPT_fschedule_insns2, NULL, 1 },
498#endif
499 { OPT_LEVELS_2_PLUS, OPT_fstrict_aliasing, NULL, 1 },
500 { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_freorder_blocks_algorithm_, NULL,
501 REORDER_BLOCKS_ALGORITHM_STC },
502 { OPT_LEVELS_2_PLUS, OPT_freorder_functions, NULL, 1 },
503 { OPT_LEVELS_2_PLUS, OPT_ftree_vrp, NULL, 1 },
504 { OPT_LEVELS_2_PLUS, OPT_fcode_hoisting, NULL, 1 },
505 { OPT_LEVELS_2_PLUS, OPT_ftree_pre, NULL, 1 },
506 { OPT_LEVELS_2_PLUS, OPT_ftree_switch_conversion, NULL, 1 },
507 { OPT_LEVELS_2_PLUS, OPT_fipa_cp, NULL, 1 },
508 { OPT_LEVELS_2_PLUS, OPT_fipa_bit_cp, NULL, 1 },
509 { OPT_LEVELS_2_PLUS, OPT_fipa_vrp, NULL, 1 },
510 { OPT_LEVELS_2_PLUS, OPT_fdevirtualize, NULL, 1 },
511 { OPT_LEVELS_2_PLUS, OPT_fdevirtualize_speculatively, NULL, 1 },
512 { OPT_LEVELS_2_PLUS, OPT_fipa_sra, NULL, 1 },
513 { OPT_LEVELS_2_PLUS, OPT_falign_loops, NULL, 1 },
514 { OPT_LEVELS_2_PLUS, OPT_falign_jumps, NULL, 1 },
515 { OPT_LEVELS_2_PLUS, OPT_falign_labels, NULL, 1 },
516 { OPT_LEVELS_2_PLUS, OPT_falign_functions, NULL, 1 },
517 { OPT_LEVELS_2_PLUS, OPT_ftree_tail_merge, NULL, 1 },
518 { OPT_LEVELS_2_PLUS, OPT_fvect_cost_model_, NULL, VECT_COST_MODEL_CHEAP },
519 { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_foptimize_strlen, NULL, 1 },
520 { OPT_LEVELS_2_PLUS, OPT_fhoist_adjacent_loads, NULL, 1 },
521 { OPT_LEVELS_2_PLUS, OPT_fipa_icf, NULL, 1 },
522 { OPT_LEVELS_2_PLUS, OPT_fisolate_erroneous_paths_dereference, NULL, 1 },
523 { OPT_LEVELS_2_PLUS, OPT_fipa_ra, NULL, 1 },
524 { OPT_LEVELS_2_PLUS, OPT_flra_remat, NULL, 1 },
525 { OPT_LEVELS_2_PLUS, OPT_fstore_merging, NULL, 1 },
526
527 /* -O3 optimizations. */
528 { OPT_LEVELS_3_PLUS, OPT_ftree_loop_distribute_patterns, NULL, 1 },
529 { OPT_LEVELS_3_PLUS, OPT_ftree_loop_distribution, NULL, 1 },
530 { OPT_LEVELS_3_PLUS, OPT_floop_interchange, NULL, 1 },
531 { OPT_LEVELS_3_PLUS, OPT_fpredictive_commoning, NULL, 1 },
532 { OPT_LEVELS_3_PLUS, OPT_fsplit_paths, NULL, 1 },
533 /* Inlining of functions reducing size is a good idea with -Os
534 regardless of them being declared inline. */
535 { OPT_LEVELS_3_PLUS_AND_SIZE, OPT_finline_functions, NULL, 1 },
536 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_finline_functions_called_once, NULL, 1 },
537 { OPT_LEVELS_3_PLUS, OPT_fsplit_loops, NULL, 1 },
538 { OPT_LEVELS_3_PLUS, OPT_funswitch_loops, NULL, 1 },
539 { OPT_LEVELS_3_PLUS, OPT_floop_unroll_and_jam, NULL, 1 },
540 { OPT_LEVELS_3_PLUS, OPT_fgcse_after_reload, NULL, 1 },
541 { OPT_LEVELS_3_PLUS, OPT_ftree_loop_vectorize, NULL, 1 },
542 { OPT_LEVELS_3_PLUS, OPT_ftree_slp_vectorize, NULL, 1 },
543 { OPT_LEVELS_3_PLUS, OPT_fvect_cost_model_, NULL, VECT_COST_MODEL_DYNAMIC },
544 { OPT_LEVELS_3_PLUS, OPT_fipa_cp_clone, NULL, 1 },
545 { OPT_LEVELS_3_PLUS, OPT_ftree_partial_pre, NULL, 1 },
546 { OPT_LEVELS_3_PLUS, OPT_fpeel_loops, NULL, 1 },
547
548 /* -Ofast adds optimizations to -O3. */
549 { OPT_LEVELS_FAST, OPT_ffast_math, NULL, 1 },
550
551 { OPT_LEVELS_NONE, 0, NULL, 0 }
552 };
553
554/* Default the options in OPTS and OPTS_SET based on the optimization
555 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
556void
557default_options_optimization (struct gcc_options *opts,
558 struct gcc_options *opts_set,
559 struct cl_decoded_option *decoded_options,
560 unsigned int decoded_options_count,
561 location_t loc,
562 unsigned int lang_mask,
563 const struct cl_option_handlers *handlers,
564 diagnostic_context *dc)
565{
566 unsigned int i;
567 int opt2;
568 bool openacc_mode = false;
569
570 /* Scan to see what optimization level has been specified. That will
571 determine the default value of many flags. */
572 for (i = 1; i < decoded_options_count; i++)
573 {
574 struct cl_decoded_option *opt = &decoded_options[i];
575 switch (opt->opt_index)
576 {
577 case OPT_O:
578 if (*opt->arg == '\0')
579 {
580 opts->x_optimize = 1;
581 opts->x_optimize_size = 0;
582 opts->x_optimize_fast = 0;
583 opts->x_optimize_debug = 0;
584 }
585 else
586 {
587 const int optimize_val = integral_argument (opt->arg);
588 if (optimize_val == -1)
589 error_at (loc, "argument to %<-O%> should be a non-negative "
590 "integer, %<g%>, %<s%> or %<fast%>");
591 else
592 {
593 opts->x_optimize = optimize_val;
594 if ((unsigned int) opts->x_optimize > 255)
595 opts->x_optimize = 255;
596 opts->x_optimize_size = 0;
597 opts->x_optimize_fast = 0;
598 opts->x_optimize_debug = 0;
599 }
600 }
601 break;
602
603 case OPT_Os:
604 opts->x_optimize_size = 1;
605
606 /* Optimizing for size forces optimize to be 2. */
607 opts->x_optimize = 2;
608 opts->x_optimize_fast = 0;
609 opts->x_optimize_debug = 0;
610 break;
611
612 case OPT_Ofast:
613 /* -Ofast only adds flags to -O3. */
614 opts->x_optimize_size = 0;
615 opts->x_optimize = 3;
616 opts->x_optimize_fast = 1;
617 opts->x_optimize_debug = 0;
618 break;
619
620 case OPT_Og:
621 /* -Og selects optimization level 1. */
622 opts->x_optimize_size = 0;
623 opts->x_optimize = 1;
624 opts->x_optimize_fast = 0;
625 opts->x_optimize_debug = 1;
626 break;
627
628 case OPT_fopenacc:
629 if (opt->value)
630 openacc_mode = true;
631 break;
632
633 default:
634 /* Ignore other options in this prescan. */
635 break;
636 }
637 }
638
639 maybe_default_options (opts, opts_set, default_options_table,
640 opts->x_optimize, opts->x_optimize_size,
641 opts->x_optimize_fast, opts->x_optimize_debug,
642 lang_mask, handlers, loc, dc);
643
644 /* -O2 param settings. */
645 opt2 = (opts->x_optimize >= 2);
646
647 if (openacc_mode
648 && !opts_set->x_flag_ipa_pta)
649 opts->x_flag_ipa_pta = true;
650
651 /* Track fields in field-sensitive alias analysis. */
652 maybe_set_param_value
653 (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE,
654 opt2 ? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE),
655 opts->x_param_values, opts_set->x_param_values);
656
657 /* For -O1 only do loop invariant motion for very small loops. */
658 maybe_set_param_value
659 (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP,
660 opt2 ? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP) : 1000,
661 opts->x_param_values, opts_set->x_param_values);
662
663 /* At -Ofast, allow store motion to introduce potential race conditions. */
664 maybe_set_param_value
665 (PARAM_ALLOW_STORE_DATA_RACES,
666 opts->x_optimize_fast ? 1
667 : default_param_value (PARAM_ALLOW_STORE_DATA_RACES),
668 opts->x_param_values, opts_set->x_param_values);
669
670 if (opts->x_optimize_size)
671 /* We want to crossjump as much as possible. */
672 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS, 1,
673 opts->x_param_values, opts_set->x_param_values);
674 else
675 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS,
676 default_param_value (PARAM_MIN_CROSSJUMP_INSNS),
677 opts->x_param_values, opts_set->x_param_values);
678
679 /* Restrict the amount of work combine does at -Og while retaining
680 most of its useful transforms. */
681 if (opts->x_optimize_debug)
682 maybe_set_param_value (PARAM_MAX_COMBINE_INSNS, 2,
683 opts->x_param_values, opts_set->x_param_values);
684
685 /* Allow default optimizations to be specified on a per-machine basis. */
686 maybe_default_options (opts, opts_set,
687 targetm_common.option_optimization_table,
688 opts->x_optimize, opts->x_optimize_size,
689 opts->x_optimize_fast, opts->x_optimize_debug,
690 lang_mask, handlers, loc, dc);
691}
692
693/* After all options at LOC have been read into OPTS and OPTS_SET,
694 finalize settings of those options and diagnose incompatible
695 combinations. */
696void
697finish_options (struct gcc_options *opts, struct gcc_options *opts_set,
698 location_t loc)
699{
700 enum unwind_info_type ui_except;
701
702 if (opts->x_dump_base_name
703 && ! IS_ABSOLUTE_PATH (opts->x_dump_base_name)
704 && ! opts->x_dump_base_name_prefixed)
705 {
706 /* First try to make OPTS->X_DUMP_BASE_NAME relative to the
707 OPTS->X_DUMP_DIR_NAME directory. Then try to make
708 OPTS->X_DUMP_BASE_NAME relative to the OPTS->X_AUX_BASE_NAME
709 directory, typically the directory to contain the object
710 file. */
711 if (opts->x_dump_dir_name)
712 opts->x_dump_base_name = opts_concat (opts->x_dump_dir_name,
713 opts->x_dump_base_name, NULL);
714 else if (opts->x_aux_base_name
715 && strcmp (opts->x_aux_base_name, HOST_BIT_BUCKET) != 0)
716 {
717 const char *aux_base;
718
719 base_of_path (opts->x_aux_base_name, &aux_base);
720 if (opts->x_aux_base_name != aux_base)
721 {
722 int dir_len = aux_base - opts->x_aux_base_name;
723 char *new_dump_base_name
724 = XOBNEWVEC (&opts_obstack, char,
725 strlen (opts->x_dump_base_name) + dir_len + 1);
726
727 /* Copy directory component from OPTS->X_AUX_BASE_NAME. */
728 memcpy (new_dump_base_name, opts->x_aux_base_name, dir_len);
729 /* Append existing OPTS->X_DUMP_BASE_NAME. */
730 strcpy (new_dump_base_name + dir_len, opts->x_dump_base_name);
731 opts->x_dump_base_name = new_dump_base_name;
732 }
733 }
734 opts->x_dump_base_name_prefixed = true;
735 }
736
737 /* Handle related options for unit-at-a-time, toplevel-reorder, and
738 section-anchors. */
739 if (!opts->x_flag_unit_at_a_time)
740 {
741 if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
742 error_at (loc, "section anchors must be disabled when unit-at-a-time "
743 "is disabled");
744 opts->x_flag_section_anchors = 0;
745 if (opts->x_flag_toplevel_reorder == 1)
746 error_at (loc, "toplevel reorder must be disabled when unit-at-a-time "
747 "is disabled");
748 opts->x_flag_toplevel_reorder = 0;
749 }
750
751 /* -fself-test depends on the state of the compiler prior to
752 compiling anything. Ideally it should be run on an empty source
753 file. However, in case we get run with actual source, assume
754 -fsyntax-only which will inhibit any compiler initialization
755 which may confuse the self tests. */
756 if (opts->x_flag_self_test)
757 opts->x_flag_syntax_only = 1;
758
759 if (opts->x_flag_tm && opts->x_flag_non_call_exceptions)
760 sorry ("transactional memory is not supported with non-call exceptions");
761
762 /* Unless the user has asked for section anchors, we disable toplevel
763 reordering at -O0 to disable transformations that might be surprising
764 to end users and to get -fno-toplevel-reorder tested. */
765 if (!opts->x_optimize
766 && opts->x_flag_toplevel_reorder == 2
767 && !(opts->x_flag_section_anchors && opts_set->x_flag_section_anchors))
768 {
769 opts->x_flag_toplevel_reorder = 0;
770 opts->x_flag_section_anchors = 0;
771 }
772 if (!opts->x_flag_toplevel_reorder)
773 {
774 if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
775 error_at (loc, "section anchors must be disabled when toplevel reorder"
776 " is disabled");
777 opts->x_flag_section_anchors = 0;
778 }
779
780 if (!opts->x_flag_opts_finished)
781 {
782 /* We initialize opts->x_flag_pie to -1 so that targets can set a
783 default value. */
784 if (opts->x_flag_pie == -1)
785 {
786 /* We initialize opts->x_flag_pic to -1 so that we can tell if
787 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
788 if (opts->x_flag_pic == -1)
789 opts->x_flag_pie = DEFAULT_FLAG_PIE;
790 else
791 opts->x_flag_pie = 0;
792 }
793 /* If -fPIE or -fpie is used, turn on PIC. */
794 if (opts->x_flag_pie)
795 opts->x_flag_pic = opts->x_flag_pie;
796 else if (opts->x_flag_pic == -1)
797 opts->x_flag_pic = 0;
798 if (opts->x_flag_pic && !opts->x_flag_pie)
799 opts->x_flag_shlib = 1;
800 opts->x_flag_opts_finished = true;
801 }
802
803 /* We initialize opts->x_flag_stack_protect to -1 so that targets
804 can set a default value. */
805 if (opts->x_flag_stack_protect == -1)
806 opts->x_flag_stack_protect = DEFAULT_FLAG_SSP;
807
808 if (opts->x_optimize == 0)
809 {
810 /* Inlining does not work if not optimizing,
811 so force it not to be done. */
812 opts->x_warn_inline = 0;
813 opts->x_flag_no_inline = 1;
814 }
815
816 /* The optimization to partition hot and cold basic blocks into separate
817 sections of the .o and executable files does not work (currently)
818 with exception handling. This is because there is no support for
819 generating unwind info. If opts->x_flag_exceptions is turned on
820 we need to turn off the partitioning optimization. */
821
822 ui_except = targetm_common.except_unwind_info (opts);
823
824 if (opts->x_flag_exceptions
825 && opts->x_flag_reorder_blocks_and_partition
826 && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))
827 {
828 if (opts_set->x_flag_reorder_blocks_and_partition)
829 inform (loc,
830 "%<-freorder-blocks-and-partition%> does not work "
831 "with exceptions on this architecture");
832 opts->x_flag_reorder_blocks_and_partition = 0;
833 opts->x_flag_reorder_blocks = 1;
834 }
835
836 /* If user requested unwind info, then turn off the partitioning
837 optimization. */
838
839 if (opts->x_flag_unwind_tables
840 && !targetm_common.unwind_tables_default
841 && opts->x_flag_reorder_blocks_and_partition
842 && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))
843 {
844 if (opts_set->x_flag_reorder_blocks_and_partition)
845 inform (loc,
846 "%<-freorder-blocks-and-partition%> does not support "
847 "unwind info on this architecture");
848 opts->x_flag_reorder_blocks_and_partition = 0;
849 opts->x_flag_reorder_blocks = 1;
850 }
851
852 /* If the target requested unwind info, then turn off the partitioning
853 optimization with a different message. Likewise, if the target does not
854 support named sections. */
855
856 if (opts->x_flag_reorder_blocks_and_partition
857 && (!targetm_common.have_named_sections
858 || (opts->x_flag_unwind_tables
859 && targetm_common.unwind_tables_default
860 && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))))
861 {
862 if (opts_set->x_flag_reorder_blocks_and_partition)
863 inform (loc,
864 "%<-freorder-blocks-and-partition%> does not work "
865 "on this architecture");
866 opts->x_flag_reorder_blocks_and_partition = 0;
867 opts->x_flag_reorder_blocks = 1;
868 }
869
870
871 /* Pipelining of outer loops is only possible when general pipelining
872 capabilities are requested. */
873 if (!opts->x_flag_sel_sched_pipelining)
874 opts->x_flag_sel_sched_pipelining_outer_loops = 0;
875
876 if (opts->x_flag_conserve_stack)
877 {
878 maybe_set_param_value (PARAM_LARGE_STACK_FRAME, 100,
879 opts->x_param_values, opts_set->x_param_values);
880 maybe_set_param_value (PARAM_STACK_FRAME_GROWTH, 40,
881 opts->x_param_values, opts_set->x_param_values);
882 }
883
884 if (opts->x_flag_lto)
885 {
886#ifdef ENABLE_LTO
887 opts->x_flag_generate_lto = 1;
888
889 /* When generating IL, do not operate in whole-program mode.
890 Otherwise, symbols will be privatized too early, causing link
891 errors later. */
892 opts->x_flag_whole_program = 0;
893#else
894 error_at (loc, "LTO support has not been enabled in this configuration");
895#endif
896 if (!opts->x_flag_fat_lto_objects
897 && (!HAVE_LTO_PLUGIN
898 || (opts_set->x_flag_use_linker_plugin
899 && !opts->x_flag_use_linker_plugin)))
900 {
901 if (opts_set->x_flag_fat_lto_objects)
902 error_at (loc, "%<-fno-fat-lto-objects%> are supported only with "
903 "linker plugin");
904 opts->x_flag_fat_lto_objects = 1;
905 }
906 }
907
908 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
909 default value if they choose based on other options. */
910 if (opts->x_flag_split_stack == -1)
911 opts->x_flag_split_stack = 0;
912 else if (opts->x_flag_split_stack)
913 {
914 if (!targetm_common.supports_split_stack (true, opts))
915 {
916 error_at (loc, "%<-fsplit-stack%> is not supported by "
917 "this compiler configuration");
918 opts->x_flag_split_stack = 0;
919 }
920 }
921
922 /* If stack splitting is turned on, and the user did not explicitly
923 request function partitioning, turn off partitioning, as it
924 confuses the linker when trying to handle partitioned split-stack
925 code that calls a non-split-stack functions. But if partitioning
926 was turned on explicitly just hope for the best. */
927 if (opts->x_flag_split_stack
928 && opts->x_flag_reorder_blocks_and_partition
929 && !opts_set->x_flag_reorder_blocks_and_partition)
930 opts->x_flag_reorder_blocks_and_partition = 0;
931
932 if (opts->x_flag_reorder_blocks_and_partition
933 && !opts_set->x_flag_reorder_functions)
934 opts->x_flag_reorder_functions = 1;
935
936 /* Tune vectorization related parametees according to cost model. */
937 if (opts->x_flag_vect_cost_model == VECT_COST_MODEL_CHEAP)
938 {
939 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS,
940 6, opts->x_param_values, opts_set->x_param_values);
941 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS,
942 0, opts->x_param_values, opts_set->x_param_values);
943 maybe_set_param_value (PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT,
944 0, opts->x_param_values, opts_set->x_param_values);
945 }
946
947 /* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
948 is disabled. */
949 if ((!opts->x_flag_tree_loop_vectorize && !opts->x_flag_tree_slp_vectorize)
950 || !opts->x_flag_tree_loop_if_convert)
951 maybe_set_param_value (PARAM_MAX_STORES_TO_SINK, 0,
952 opts->x_param_values, opts_set->x_param_values);
953
954 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
955 if (opts->x_dwarf_split_debug_info)
956 opts->x_debug_generate_pub_sections = 2;
957
958 if ((opts->x_flag_sanitize
959 & (SANITIZE_USER_ADDRESS | SANITIZE_KERNEL_ADDRESS)) == 0)
960 {
961 if (opts->x_flag_sanitize & SANITIZE_POINTER_COMPARE)
962 error_at (loc,
963 "%<-fsanitize=pointer-compare%> must be combined with "
964 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
965 if (opts->x_flag_sanitize & SANITIZE_POINTER_SUBTRACT)
966 error_at (loc,
967 "%<-fsanitize=pointer-subtract%> must be combined with "
968 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
969 }
970
971 /* Userspace and kernel ASan conflict with each other. */
972 if ((opts->x_flag_sanitize & SANITIZE_USER_ADDRESS)
973 && (opts->x_flag_sanitize & SANITIZE_KERNEL_ADDRESS))
974 error_at (loc,
975 "%<-fsanitize=address%> is incompatible with "
976 "%<-fsanitize=kernel-address%>");
977
978 /* And with TSan. */
979 if ((opts->x_flag_sanitize & SANITIZE_ADDRESS)
980 && (opts->x_flag_sanitize & SANITIZE_THREAD))
981 error_at (loc,
982 "%<-fsanitize=address%> and %<-fsanitize=kernel-address%> "
983 "are incompatible with %<-fsanitize=thread%>");
984
985 if ((opts->x_flag_sanitize & SANITIZE_LEAK)
986 && (opts->x_flag_sanitize & SANITIZE_THREAD))
987 error_at (loc,
988 "%<-fsanitize=leak%> is incompatible with %<-fsanitize=thread%>");
989
990 /* Check error recovery for -fsanitize-recover option. */
991 for (int i = 0; sanitizer_opts[i].name != NULL; ++i)
992 if ((opts->x_flag_sanitize_recover & sanitizer_opts[i].flag)
993 && !sanitizer_opts[i].can_recover)
994 error_at (loc, "%<-fsanitize-recover=%s%> is not supported",
995 sanitizer_opts[i].name);
996
997 /* When instrumenting the pointers, we don't want to remove
998 the null pointer checks. */
999 if (opts->x_flag_sanitize & (SANITIZE_NULL | SANITIZE_NONNULL_ATTRIBUTE
1000 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE))
1001 opts->x_flag_delete_null_pointer_checks = 0;
1002
1003 /* Aggressive compiler optimizations may cause false negatives. */
1004 if (opts->x_flag_sanitize & ~(SANITIZE_LEAK | SANITIZE_UNREACHABLE))
1005 opts->x_flag_aggressive_loop_optimizations = 0;
1006
1007 /* Enable -fsanitize-address-use-after-scope if address sanitizer is
1008 enabled. */
1009 if ((opts->x_flag_sanitize & SANITIZE_USER_ADDRESS)
1010 && !opts_set->x_flag_sanitize_address_use_after_scope)
1011 opts->x_flag_sanitize_address_use_after_scope = true;
1012
1013 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1014 is enabled. */
1015 if (opts->x_flag_sanitize_address_use_after_scope)
1016 {
1017 if (opts->x_flag_stack_reuse != SR_NONE
1018 && opts_set->x_flag_stack_reuse != SR_NONE)
1019 error_at (loc,
1020 "%<-fsanitize-address-use-after-scope%> requires "
1021 "%<-fstack-reuse=none%> option");
1022
1023 opts->x_flag_stack_reuse = SR_NONE;
1024 }
1025
1026 if ((opts->x_flag_sanitize & SANITIZE_USER_ADDRESS) && opts->x_flag_tm)
1027 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1028
1029 if ((opts->x_flag_sanitize & SANITIZE_KERNEL_ADDRESS) && opts->x_flag_tm)
1030 sorry ("transactional memory is not supported with "
1031 "%<-fsanitize=kernel-address%>");
1032}
1033
1034#define LEFT_COLUMN 27
1035
1036/* Output ITEM, of length ITEM_WIDTH, in the left column,
1037 followed by word-wrapped HELP in a second column. */
1038static void
1039wrap_help (const char *help,
1040 const char *item,
1041 unsigned int item_width,
1042 unsigned int columns)
1043{
1044 unsigned int col_width = LEFT_COLUMN;
1045 unsigned int remaining, room, len;
1046
1047 remaining = strlen (help);
1048
1049 do
1050 {
1051 room = columns - 3 - MAX (col_width, item_width);
1052 if (room > columns)
1053 room = 0;
1054 len = remaining;
1055
1056 if (room < len)
1057 {
1058 unsigned int i;
1059
1060 for (i = 0; help[i]; i++)
1061 {
1062 if (i >= room && len != remaining)
1063 break;
1064 if (help[i] == ' ')
1065 len = i;
1066 else if ((help[i] == '-' || help[i] == '/')
1067 && help[i + 1] != ' '
1068 && i > 0 && ISALPHA (help[i - 1]))
1069 len = i + 1;
1070 }
1071 }
1072
1073 printf (" %-*.*s %.*s\n", col_width, item_width, item, len, help);
1074 item_width = 0;
1075 while (help[len] == ' ')
1076 len++;
1077 help += len;
1078 remaining -= len;
1079 }
1080 while (remaining);
1081}
1082
1083/* Print help for a specific front-end, etc. */
1084static void
1085print_filtered_help (unsigned int include_flags,
1086 unsigned int exclude_flags,
1087 unsigned int any_flags,
1088 unsigned int columns,
1089 struct gcc_options *opts,
1090 unsigned int lang_mask)
1091{
1092 unsigned int i;
1093 const char *help;
1094 bool found = false;
1095 bool displayed = false;
1096 char new_help[256];
1097
1098 if (include_flags == CL_PARAMS)
1099 {
1100 for (i = 0; i < LAST_PARAM; i++)
1101 {
1102 const char *param = compiler_params[i].option;
1103
1104 help = compiler_params[i].help;
1105 if (help == NULL || *help == '\0')
1106 {
1107 if (exclude_flags & CL_UNDOCUMENTED)
1108 continue;
1109 help = undocumented_msg;
1110 }
1111
1112 /* Get the translation. */
1113 help = _(help);
1114
1115 if (!opts->x_quiet_flag)
1116 {
1117 snprintf (new_help, sizeof (new_help),
1118 _("default %d minimum %d maximum %d"),
1119 compiler_params[i].default_value,
1120 compiler_params[i].min_value,
1121 compiler_params[i].max_value);
1122 help = new_help;
1123 }
1124 wrap_help (help, param, strlen (param), columns);
1125 }
1126 putchar ('\n');
1127 return;
1128 }
1129
1130 if (!opts->x_help_printed)
1131 opts->x_help_printed = XCNEWVAR (char, cl_options_count);
1132
1133 if (!opts->x_help_enum_printed)
1134 opts->x_help_enum_printed = XCNEWVAR (char, cl_enums_count);
1135
1136 for (i = 0; i < cl_options_count; i++)
1137 {
1138 const struct cl_option *option = cl_options + i;
1139 unsigned int len;
1140 const char *opt;
1141 const char *tab;
1142
1143 if (include_flags == 0
1144 || ((option->flags & include_flags) != include_flags))
1145 {
1146 if ((option->flags & any_flags) == 0)
1147 continue;
1148 }
1149
1150 /* Skip unwanted switches. */
1151 if ((option->flags & exclude_flags) != 0)
1152 continue;
1153
1154 /* The driver currently prints its own help text. */
1155 if ((option->flags & CL_DRIVER) != 0
1156 && (option->flags & (((1U << cl_lang_count) - 1)
1157 | CL_COMMON | CL_TARGET)) == 0)
1158 continue;
1159
1160 found = true;
1161 /* Skip switches that have already been printed. */
1162 if (opts->x_help_printed[i])
1163 continue;
1164
1165 opts->x_help_printed[i] = true;
1166
1167 help = option->help;
1168 if (help == NULL)
1169 {
1170 if (exclude_flags & CL_UNDOCUMENTED)
1171 continue;
1172
1173 help = undocumented_msg;
1174 }
1175
1176 if (option->alias_target < N_OPTS
1177 && cl_options [option->alias_target].help)
1178 {
1179 if (help == undocumented_msg)
1180 {
1181 /* For undocumented options that are aliases for other options
1182 that are documented, point the reader to the other option in
1183 preference of the former. */
1184 snprintf (new_help, sizeof new_help,
1185 _("Same as %s. Use the latter option instead."),
1186 cl_options [option->alias_target].opt_text);
1187 }
1188 else
1189 {
1190 /* For documented options with aliases, mention the aliased
1191 option's name for reference. */
1192 snprintf (new_help, sizeof new_help,
1193 _("%s Same as %s."),
1194 help, cl_options [option->alias_target].opt_text);
1195 }
1196
1197 help = new_help;
1198 }
1199
1200 if (option->warn_message)
1201 {
1202 /* Mention that the use of the option will trigger a warning. */
1203 if (help == new_help)
1204 snprintf (new_help + strlen (new_help),
1205 sizeof new_help - strlen (new_help),
1206 " %s", _(use_diagnosed_msg));
1207 else
1208 snprintf (new_help, sizeof new_help,
1209 "%s %s", help, _(use_diagnosed_msg));
1210
1211 help = new_help;
1212 }
1213
1214 /* Get the translation. */
1215 help = _(help);
1216
1217 /* Find the gap between the name of the
1218 option and its descriptive text. */
1219 tab = strchr (help, '\t');
1220 if (tab)
1221 {
1222 len = tab - help;
1223 opt = help;
1224 help = tab + 1;
1225 }
1226 else
1227 {
1228 opt = option->opt_text;
1229 len = strlen (opt);
1230 }
1231
1232 /* With the -Q option enabled we change the descriptive text associated
1233 with an option to be an indication of its current setting. */
1234 if (!opts->x_quiet_flag)
1235 {
1236 void *flag_var = option_flag_var (i, opts);
1237
1238 if (len < (LEFT_COLUMN + 2))
1239 strcpy (new_help, "\t\t");
1240 else
1241 strcpy (new_help, "\t");
1242
1243 if (flag_var != NULL
1244 && option->var_type != CLVC_DEFER)
1245 {
1246 if (option->flags & CL_JOINED)
1247 {
1248 if (option->var_type == CLVC_STRING)
1249 {
1250 if (* (const char **) flag_var != NULL)
1251 snprintf (new_help + strlen (new_help),
1252 sizeof (new_help) - strlen (new_help),
1253 "%s", * (const char **) flag_var);
1254 }
1255 else if (option->var_type == CLVC_ENUM)
1256 {
1257 const struct cl_enum *e = &cl_enums[option->var_enum];
1258 int value;
1259 const char *arg = NULL;
1260
1261 value = e->get (flag_var);
1262 enum_value_to_arg (e->values, &arg, value, lang_mask);
1263 if (arg == NULL)
1264 arg = _("[default]");
1265 snprintf (new_help + strlen (new_help),
1266 sizeof (new_help) - strlen (new_help),
1267 "%s", arg);
1268 }
1269 else
1270 sprintf (new_help + strlen (new_help),
1271 "%d", * (int *) flag_var);
1272 }
1273 else
1274 strcat (new_help, option_enabled (i, opts)
1275 ? _("[enabled]") : _("[disabled]"));
1276 }
1277
1278 help = new_help;
1279 }
1280
1281 if (option->range_max != -1)
1282 {
1283 char b[128];
1284 snprintf (b, sizeof (b), "<%d,%d>", option->range_min,
1285 option->range_max);
1286 opt = concat (opt, b, NULL);
1287 len += strlen (b);
1288 }
1289
1290 wrap_help (help, opt, len, columns);
1291 displayed = true;
1292
1293 if (option->var_type == CLVC_ENUM
1294 && opts->x_help_enum_printed[option->var_enum] != 2)
1295 opts->x_help_enum_printed[option->var_enum] = 1;
1296 }
1297
1298 if (! found)
1299 {
1300 unsigned int langs = include_flags & CL_LANG_ALL;
1301
1302 if (langs == 0)
1303 printf (_(" No options with the desired characteristics were found\n"));
1304 else
1305 {
1306 unsigned int i;
1307
1308 /* PR 31349: Tell the user how to see all of the
1309 options supported by a specific front end. */
1310 for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1311 if ((1U << i) & langs)
1312 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1313 lang_names[i], lang_names[i]);
1314 }
1315
1316 }
1317 else if (! displayed)
1318 printf (_(" All options with the desired characteristics have already been displayed\n"));
1319
1320 putchar ('\n');
1321
1322 /* Print details of enumerated option arguments, if those
1323 enumerations have help text headings provided. If no help text
1324 is provided, presume that the possible values are listed in the
1325 help text for the relevant options. */
1326 for (i = 0; i < cl_enums_count; i++)
1327 {
1328 unsigned int j, pos;
1329
1330 if (opts->x_help_enum_printed[i] != 1)
1331 continue;
1332 if (cl_enums[i].help == NULL)
1333 continue;
1334 printf (" %s\n ", _(cl_enums[i].help));
1335 pos = 4;
1336 for (j = 0; cl_enums[i].values[j].arg != NULL; j++)
1337 {
1338 unsigned int len = strlen (cl_enums[i].values[j].arg);
1339
1340 if (pos > 4 && pos + 1 + len <= columns)
1341 {
1342 printf (" %s", cl_enums[i].values[j].arg);
1343 pos += 1 + len;
1344 }
1345 else
1346 {
1347 if (pos > 4)
1348 {
1349 printf ("\n ");
1350 pos = 4;
1351 }
1352 printf ("%s", cl_enums[i].values[j].arg);
1353 pos += len;
1354 }
1355 }
1356 printf ("\n\n");
1357 opts->x_help_enum_printed[i] = 2;
1358 }
1359}
1360
1361/* Display help for a specified type of option.
1362 The options must have ALL of the INCLUDE_FLAGS set
1363 ANY of the flags in the ANY_FLAGS set
1364 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1365 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1366static void
1367print_specific_help (unsigned int include_flags,
1368 unsigned int exclude_flags,
1369 unsigned int any_flags,
1370 struct gcc_options *opts,
1371 unsigned int lang_mask)
1372{
1373 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1374 const char * description = NULL;
1375 const char * descrip_extra = "";
1376 size_t i;
1377 unsigned int flag;
1378
1379 /* Sanity check: Make sure that we do not have more
1380 languages than we have bits available to enumerate them. */
1381 gcc_assert ((1U << cl_lang_count) <= CL_MIN_OPTION_CLASS);
1382
1383 /* If we have not done so already, obtain
1384 the desired maximum width of the output. */
1385 if (opts->x_help_columns == 0)
1386 {
1387 opts->x_help_columns = get_terminal_width ();
1388 if (opts->x_help_columns == INT_MAX)
1389 /* Use a reasonable default. */
1390 opts->x_help_columns = 80;
1391 }
1392
1393 /* Decide upon the title for the options that we are going to display. */
1394 for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1395 {
1396 switch (flag & include_flags)
1397 {
1398 case 0:
1399 case CL_DRIVER:
1400 break;
1401
1402 case CL_TARGET:
1403 description = _("The following options are target specific");
1404 break;
1405 case CL_WARNING:
1406 description = _("The following options control compiler warning messages");
1407 break;
1408 case CL_OPTIMIZATION:
1409 description = _("The following options control optimizations");
1410 break;
1411 case CL_COMMON:
1412 description = _("The following options are language-independent");
1413 break;
1414 case CL_PARAMS:
1415 description = _("The --param option recognizes the following as parameters");
1416 break;
1417 default:
1418 if (i >= cl_lang_count)
1419 break;
1420 if (exclude_flags & all_langs_mask)
1421 description = _("The following options are specific to just the language ");
1422 else
1423 description = _("The following options are supported by the language ");
1424 descrip_extra = lang_names [i];
1425 break;
1426 }
1427 }
1428
1429 if (description == NULL)
1430 {
1431 if (any_flags == 0)
1432 {
1433 if (include_flags & CL_UNDOCUMENTED)
1434 description = _("The following options are not documented");
1435 else if (include_flags & CL_SEPARATE)
1436 description = _("The following options take separate arguments");
1437 else if (include_flags & CL_JOINED)
1438 description = _("The following options take joined arguments");
1439 else
1440 {
1441 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1442 include_flags);
1443 return;
1444 }
1445 }
1446 else
1447 {
1448 if (any_flags & all_langs_mask)
1449 description = _("The following options are language-related");
1450 else
1451 description = _("The following options are language-independent");
1452 }
1453 }
1454
1455 printf ("%s%s:\n", description, descrip_extra);
1456 print_filtered_help (include_flags, exclude_flags, any_flags,
1457 opts->x_help_columns, opts, lang_mask);
1458}
1459
1460/* Enable FDO-related flags. */
1461
1462static void
1463enable_fdo_optimizations (struct gcc_options *opts,
1464 struct gcc_options *opts_set,
1465 int value)
1466{
1467 if (!opts_set->x_flag_branch_probabilities)
1468 opts->x_flag_branch_probabilities = value;
1469 if (!opts_set->x_flag_profile_values)
1470 opts->x_flag_profile_values = value;
1471 if (!opts_set->x_flag_unroll_loops)
1472 opts->x_flag_unroll_loops = value;
1473 if (!opts_set->x_flag_peel_loops)
1474 opts->x_flag_peel_loops = value;
1475 if (!opts_set->x_flag_tracer)
1476 opts->x_flag_tracer = value;
1477 if (!opts_set->x_flag_value_profile_transformations)
1478 opts->x_flag_value_profile_transformations = value;
1479 if (!opts_set->x_flag_inline_functions)
1480 opts->x_flag_inline_functions = value;
1481 if (!opts_set->x_flag_ipa_cp)
1482 opts->x_flag_ipa_cp = value;
1483 if (!opts_set->x_flag_ipa_cp_clone
1484 && value && opts->x_flag_ipa_cp)
1485 opts->x_flag_ipa_cp_clone = value;
1486 if (!opts_set->x_flag_ipa_bit_cp
1487 && value && opts->x_flag_ipa_cp)
1488 opts->x_flag_ipa_bit_cp = value;
1489 if (!opts_set->x_flag_predictive_commoning)
1490 opts->x_flag_predictive_commoning = value;
1491 if (!opts_set->x_flag_split_loops)
1492 opts->x_flag_split_loops = value;
1493 if (!opts_set->x_flag_unswitch_loops)
1494 opts->x_flag_unswitch_loops = value;
1495 if (!opts_set->x_flag_gcse_after_reload)
1496 opts->x_flag_gcse_after_reload = value;
1497 if (!opts_set->x_flag_tree_loop_vectorize)
1498 opts->x_flag_tree_loop_vectorize = value;
1499 if (!opts_set->x_flag_tree_slp_vectorize)
1500 opts->x_flag_tree_slp_vectorize = value;
1501 if (!opts_set->x_flag_vect_cost_model)
1502 opts->x_flag_vect_cost_model = VECT_COST_MODEL_DYNAMIC;
1503 if (!opts_set->x_flag_tree_loop_distribute_patterns)
1504 opts->x_flag_tree_loop_distribute_patterns = value;
1505}
1506
1507/* -f{,no-}sanitize{,-recover}= suboptions. */
1508const struct sanitizer_opts_s sanitizer_opts[] =
1509{
1510#define SANITIZER_OPT(name, flags, recover) \
1511 { #name, flags, sizeof #name - 1, recover }
1512 SANITIZER_OPT (address, (SANITIZE_ADDRESS | SANITIZE_USER_ADDRESS), true),
1513 SANITIZER_OPT (kernel-address, (SANITIZE_ADDRESS | SANITIZE_KERNEL_ADDRESS),
1514 true),
1515 SANITIZER_OPT (pointer-compare, SANITIZE_POINTER_COMPARE, true),
1516 SANITIZER_OPT (pointer-subtract, SANITIZE_POINTER_SUBTRACT, true),
1517 SANITIZER_OPT (thread, SANITIZE_THREAD, false),
1518 SANITIZER_OPT (leak, SANITIZE_LEAK, false),
1519 SANITIZER_OPT (shift, SANITIZE_SHIFT, true),
1520 SANITIZER_OPT (shift-base, SANITIZE_SHIFT_BASE, true),
1521 SANITIZER_OPT (shift-exponent, SANITIZE_SHIFT_EXPONENT, true),
1522 SANITIZER_OPT (integer-divide-by-zero, SANITIZE_DIVIDE, true),
1523 SANITIZER_OPT (undefined, SANITIZE_UNDEFINED, true),
1524 SANITIZER_OPT (unreachable, SANITIZE_UNREACHABLE, false),
1525 SANITIZER_OPT (vla-bound, SANITIZE_VLA, true),
1526 SANITIZER_OPT (return, SANITIZE_RETURN, false),
1527 SANITIZER_OPT (null, SANITIZE_NULL, true),
1528 SANITIZER_OPT (signed-integer-overflow, SANITIZE_SI_OVERFLOW, true),
1529 SANITIZER_OPT (bool, SANITIZE_BOOL, true),
1530 SANITIZER_OPT (enum, SANITIZE_ENUM, true),
1531 SANITIZER_OPT (float-divide-by-zero, SANITIZE_FLOAT_DIVIDE, true),
1532 SANITIZER_OPT (float-cast-overflow, SANITIZE_FLOAT_CAST, true),
1533 SANITIZER_OPT (bounds, SANITIZE_BOUNDS, true),
1534 SANITIZER_OPT (bounds-strict, SANITIZE_BOUNDS | SANITIZE_BOUNDS_STRICT, true),
1535 SANITIZER_OPT (alignment, SANITIZE_ALIGNMENT, true),
1536 SANITIZER_OPT (nonnull-attribute, SANITIZE_NONNULL_ATTRIBUTE, true),
1537 SANITIZER_OPT (returns-nonnull-attribute, SANITIZE_RETURNS_NONNULL_ATTRIBUTE,
1538 true),
1539 SANITIZER_OPT (object-size, SANITIZE_OBJECT_SIZE, true),
1540 SANITIZER_OPT (vptr, SANITIZE_VPTR, true),
1541 SANITIZER_OPT (pointer-overflow, SANITIZE_POINTER_OVERFLOW, true),
1542 SANITIZER_OPT (builtin, SANITIZE_BUILTIN, true),
1543 SANITIZER_OPT (all, ~0U, true),
1544#undef SANITIZER_OPT
1545 { NULL, 0U, 0UL, false }
1546};
1547
1548/* -f{,no-}sanitize-coverage= suboptions. */
1549const struct sanitizer_opts_s coverage_sanitizer_opts[] =
1550{
1551#define COVERAGE_SANITIZER_OPT(name, flags) \
1552 { #name, flags, sizeof #name - 1, true }
1553 COVERAGE_SANITIZER_OPT (trace-pc, SANITIZE_COV_TRACE_PC),
1554 COVERAGE_SANITIZER_OPT (trace-cmp, SANITIZE_COV_TRACE_CMP),
1555#undef COVERAGE_SANITIZER_OPT
1556 { NULL, 0U, 0UL, false }
1557};
1558
1559/* A struct for describing a run of chars within a string. */
1560
1561struct string_fragment
1562{
1563 string_fragment (const char *start, size_t len)
1564 : m_start (start), m_len (len) {}
1565
1566 const char *m_start;
1567 size_t m_len;
1568};
1569
1570/* Specialization of edit_distance_traits for string_fragment,
1571 for use by get_closest_sanitizer_option. */
1572
1573template <>
1574struct edit_distance_traits<const string_fragment &>
1575{
1576 static size_t get_length (const string_fragment &fragment)
1577 {
1578 return fragment.m_len;
1579 }
1580
1581 static const char *get_string (const string_fragment &fragment)
1582 {
1583 return fragment.m_start;
1584 }
1585};
1586
1587/* Given ARG, an unrecognized sanitizer option, return the best
1588 matching sanitizer option, or NULL if there isn't one.
1589 OPTS is array of candidate sanitizer options.
1590 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or
1591 OPT_fsanitize_coverage_.
1592 VALUE is non-zero for the regular form of the option, zero
1593 for the "no-" form (e.g. "-fno-sanitize-recover="). */
1594
1595static const char *
1596get_closest_sanitizer_option (const string_fragment &arg,
1597 const struct sanitizer_opts_s *opts,
1598 enum opt_code code, int value)
1599{
1600 best_match <const string_fragment &, const char*> bm (arg);
1601 for (int i = 0; opts[i].name != NULL; ++i)
1602 {
1603 /* -fsanitize=all is not valid, so don't offer it. */
1604 if (code == OPT_fsanitize_
1605 && opts[i].flag == ~0U
1606 && value)
1607 continue;
1608
1609 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
1610 don't offer the non-recoverable options. */
1611 if (code == OPT_fsanitize_recover_
1612 && !opts[i].can_recover
1613 && value)
1614 continue;
1615
1616 bm.consider (opts[i].name);
1617 }
1618 return bm.get_best_meaningful_candidate ();
1619}
1620
1621/* Parse comma separated sanitizer suboptions from P for option SCODE,
1622 adjust previous FLAGS and return new ones. If COMPLAIN is false,
1623 don't issue diagnostics. */
1624
1625unsigned int
1626parse_sanitizer_options (const char *p, location_t loc, int scode,
1627 unsigned int flags, int value, bool complain)
1628{
1629 enum opt_code code = (enum opt_code) scode;
1630
1631 const struct sanitizer_opts_s *opts;
1632 if (code == OPT_fsanitize_coverage_)
1633 opts = coverage_sanitizer_opts;
1634 else
1635 opts = sanitizer_opts;
1636
1637 while (*p != 0)
1638 {
1639 size_t len, i;
1640 bool found = false;
1641 const char *comma = strchr (p, ',');
1642
1643 if (comma == NULL)
1644 len = strlen (p);
1645 else
1646 len = comma - p;
1647 if (len == 0)
1648 {
1649 p = comma + 1;
1650 continue;
1651 }
1652
1653 /* Check to see if the string matches an option class name. */
1654 for (i = 0; opts[i].name != NULL; ++i)
1655 if (len == opts[i].len && memcmp (p, opts[i].name, len) == 0)
1656 {
1657 /* Handle both -fsanitize and -fno-sanitize cases. */
1658 if (value && opts[i].flag == ~0U)
1659 {
1660 if (code == OPT_fsanitize_)
1661 {
1662 if (complain)
1663 error_at (loc, "%<-fsanitize=all%> option is not valid");
1664 }
1665 else
1666 flags |= ~(SANITIZE_THREAD | SANITIZE_LEAK
1667 | SANITIZE_UNREACHABLE | SANITIZE_RETURN);
1668 }
1669 else if (value)
1670 {
1671 /* Do not enable -fsanitize-recover=unreachable and
1672 -fsanitize-recover=return if -fsanitize-recover=undefined
1673 is selected. */
1674 if (code == OPT_fsanitize_recover_
1675 && opts[i].flag == SANITIZE_UNDEFINED)
1676 flags |= (SANITIZE_UNDEFINED
1677 & ~(SANITIZE_UNREACHABLE | SANITIZE_RETURN));
1678 else
1679 flags |= opts[i].flag;
1680 }
1681 else
1682 flags &= ~opts[i].flag;
1683 found = true;
1684 break;
1685 }
1686
1687 if (! found && complain)
1688 {
1689 const char *hint
1690 = get_closest_sanitizer_option (string_fragment (p, len),
1691 opts, code, value);
1692
1693 const char *suffix;
1694 if (code == OPT_fsanitize_recover_)
1695 suffix = "-recover";
1696 else if (code == OPT_fsanitize_coverage_)
1697 suffix = "-coverage";
1698 else
1699 suffix = "";
1700
1701 if (hint)
1702 error_at (loc,
1703 "unrecognized argument to -f%ssanitize%s= option: %q.*s;"
1704 " did you mean %qs?",
1705 value ? "" : "no-",
1706 suffix, (int) len, p, hint);
1707 else
1708 error_at (loc,
1709 "unrecognized argument to -f%ssanitize%s= option: %q.*s",
1710 value ? "" : "no-",
1711 suffix, (int) len, p);
1712 }
1713
1714 if (comma == NULL)
1715 break;
1716 p = comma + 1;
1717 }
1718 return flags;
1719}
1720
1721/* Parse string values of no_sanitize attribute passed in VALUE.
1722 Values are separated with comma. */
1723
1724unsigned int
1725parse_no_sanitize_attribute (char *value)
1726{
1727 unsigned int flags = 0;
1728 unsigned int i;
1729 char *q = strtok (value, ",");
1730
1731 while (q != NULL)
1732 {
1733 for (i = 0; sanitizer_opts[i].name != NULL; ++i)
1734 if (strcmp (sanitizer_opts[i].name, q) == 0)
1735 {
1736 flags |= sanitizer_opts[i].flag;
1737 if (sanitizer_opts[i].flag == SANITIZE_UNDEFINED)
1738 flags |= SANITIZE_UNDEFINED_NONDEFAULT;
1739 break;
1740 }
1741
1742 if (sanitizer_opts[i].name == NULL)
1743 warning (OPT_Wattributes,
1744 "%<%s%> attribute directive ignored", q);
1745
1746 q = strtok (NULL, ",");
1747 }
1748
1749 return flags;
1750}
1751
1752/* Handle target- and language-independent options. Return zero to
1753 generate an "unknown option" message. Only options that need
1754 extra handling need to be listed here; if you simply want
1755 DECODED->value assigned to a variable, it happens automatically. */
1756
1757bool
1758common_handle_option (struct gcc_options *opts,
1759 struct gcc_options *opts_set,
1760 const struct cl_decoded_option *decoded,
1761 unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
1762 location_t loc,
1763 const struct cl_option_handlers *handlers,
1764 diagnostic_context *dc,
1765 void (*target_option_override_hook) (void))
1766{
1767 size_t scode = decoded->opt_index;
1768 const char *arg = decoded->arg;
1769 int value = decoded->value;
1770 enum opt_code code = (enum opt_code) scode;
1771
1772 gcc_assert (decoded->canonical_option_num_elements <= 2);
1773
1774 switch (code)
1775 {
1776 case OPT__param:
1777 handle_param (opts, opts_set, loc, arg);
1778 break;
1779
1780 case OPT__help:
1781 {
1782 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1783 unsigned int undoc_mask;
1784 unsigned int i;
1785
1786 if (lang_mask == CL_DRIVER)
1787 break;
1788
1789 undoc_mask = ((opts->x_verbose_flag | opts->x_extra_warnings)
1790 ? 0
1791 : CL_UNDOCUMENTED);
1792 target_option_override_hook ();
1793 /* First display any single language specific options. */
1794 for (i = 0; i < cl_lang_count; i++)
1795 print_specific_help
1796 (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0, opts,
1797 lang_mask);
1798 /* Next display any multi language specific options. */
1799 print_specific_help (0, undoc_mask, all_langs_mask, opts, lang_mask);
1800 /* Then display any remaining, non-language options. */
1801 for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1802 if (i != CL_DRIVER)
1803 print_specific_help (i, undoc_mask, 0, opts, lang_mask);
1804 opts->x_exit_after_options = true;
1805 break;
1806 }
1807
1808 case OPT__target_help:
1809 if (lang_mask == CL_DRIVER)
1810 break;
1811
1812 target_option_override_hook ();
1813 print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0, opts, lang_mask);
1814 opts->x_exit_after_options = true;
1815 break;
1816
1817 case OPT__help_:
1818 {
1819 const char *a = arg;
1820 unsigned int include_flags = 0;
1821 /* Note - by default we include undocumented options when listing
1822 specific classes. If you only want to see documented options
1823 then add ",^undocumented" to the --help= option. E.g.:
1824
1825 --help=target,^undocumented */
1826 unsigned int exclude_flags = 0;
1827
1828 if (lang_mask == CL_DRIVER)
1829 break;
1830
1831 /* Walk along the argument string, parsing each word in turn.
1832 The format is:
1833 arg = [^]{word}[,{arg}]
1834 word = {optimizers|target|warnings|undocumented|
1835 params|common|<language>} */
1836 while (*a != 0)
1837 {
1838 static const struct
1839 {
1840 const char *string;
1841 unsigned int flag;
1842 }
1843 specifics[] =
1844 {
1845 { "optimizers", CL_OPTIMIZATION },
1846 { "target", CL_TARGET },
1847 { "warnings", CL_WARNING },
1848 { "undocumented", CL_UNDOCUMENTED },
1849 { "params", CL_PARAMS },
1850 { "joined", CL_JOINED },
1851 { "separate", CL_SEPARATE },
1852 { "common", CL_COMMON },
1853 { NULL, 0 }
1854 };
1855 unsigned int *pflags;
1856 const char *comma;
1857 unsigned int lang_flag, specific_flag;
1858 unsigned int len;
1859 unsigned int i;
1860
1861 if (*a == '^')
1862 {
1863 ++a;
1864 if (*a == '\0')
1865 {
1866 error_at (loc, "missing argument to %qs", "--help=^");
1867 break;
1868 }
1869 pflags = &exclude_flags;
1870 }
1871 else
1872 pflags = &include_flags;
1873
1874 comma = strchr (a, ',');
1875 if (comma == NULL)
1876 len = strlen (a);
1877 else
1878 len = comma - a;
1879 if (len == 0)
1880 {
1881 a = comma + 1;
1882 continue;
1883 }
1884
1885 /* Check to see if the string matches an option class name. */
1886 for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1887 if (strncasecmp (a, specifics[i].string, len) == 0)
1888 {
1889 specific_flag = specifics[i].flag;
1890 break;
1891 }
1892
1893 /* Check to see if the string matches a language name.
1894 Note - we rely upon the alpha-sorted nature of the entries in
1895 the lang_names array, specifically that shorter names appear
1896 before their longer variants. (i.e. C before C++). That way
1897 when we are attempting to match --help=c for example we will
1898 match with C first and not C++. */
1899 for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1900 if (strncasecmp (a, lang_names[i], len) == 0)
1901 {
1902 lang_flag = 1U << i;
1903 break;
1904 }
1905
1906 if (specific_flag != 0)
1907 {
1908 if (lang_flag == 0)
1909 *pflags |= specific_flag;
1910 else
1911 {
1912 /* The option's argument matches both the start of a
1913 language name and the start of an option class name.
1914 We have a special case for when the user has
1915 specified "--help=c", but otherwise we have to issue
1916 a warning. */
1917 if (strncasecmp (a, "c", len) == 0)
1918 *pflags |= lang_flag;
1919 else
1920 warning_at (loc, 0,
1921 "--help argument %q.*s is ambiguous, "
1922 "please be more specific",
1923 len, a);
1924 }
1925 }
1926 else if (lang_flag != 0)
1927 *pflags |= lang_flag;
1928 else
1929 warning_at (loc, 0,
1930 "unrecognized argument to --help= option: %q.*s",
1931 len, a);
1932
1933 if (comma == NULL)
1934 break;
1935 a = comma + 1;
1936 }
1937
1938 if (include_flags)
1939 {
1940 target_option_override_hook ();
1941 print_specific_help (include_flags, exclude_flags, 0, opts,
1942 lang_mask);
1943 }
1944 opts->x_exit_after_options = true;
1945 break;
1946 }
1947
1948 case OPT__version:
1949 if (lang_mask == CL_DRIVER)
1950 break;
1951
1952 opts->x_exit_after_options = true;
1953 break;
1954
1955 case OPT_fsanitize_:
1956 opts->x_flag_sanitize
1957 = parse_sanitizer_options (arg, loc, code,
1958 opts->x_flag_sanitize, value, true);
1959
1960 /* Kernel ASan implies normal ASan but does not yet support
1961 all features. */
1962 if (opts->x_flag_sanitize & SANITIZE_KERNEL_ADDRESS)
1963 {
1964 maybe_set_param_value (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD,
1965 0, opts->x_param_values,
1966 opts_set->x_param_values);
1967 maybe_set_param_value (PARAM_ASAN_GLOBALS, 0, opts->x_param_values,
1968 opts_set->x_param_values);
1969 maybe_set_param_value (PARAM_ASAN_STACK, 0, opts->x_param_values,
1970 opts_set->x_param_values);
1971 maybe_set_param_value (PARAM_ASAN_PROTECT_ALLOCAS, 0,
1972 opts->x_param_values,
1973 opts_set->x_param_values);
1974 maybe_set_param_value (PARAM_ASAN_USE_AFTER_RETURN, 0,
1975 opts->x_param_values,
1976 opts_set->x_param_values);
1977 }
1978 break;
1979
1980 case OPT_fsanitize_recover_:
1981 opts->x_flag_sanitize_recover
1982 = parse_sanitizer_options (arg, loc, code,
1983 opts->x_flag_sanitize_recover, value, true);
1984 break;
1985
1986 case OPT_fasan_shadow_offset_:
1987 /* Deferred. */
1988 break;
1989
1990 case OPT_fsanitize_address_use_after_scope:
1991 opts->x_flag_sanitize_address_use_after_scope = value;
1992 break;
1993
1994 case OPT_fsanitize_recover:
1995 if (value)
1996 opts->x_flag_sanitize_recover
1997 |= (SANITIZE_UNDEFINED | SANITIZE_UNDEFINED_NONDEFAULT)
1998 & ~(SANITIZE_UNREACHABLE | SANITIZE_RETURN);
1999 else
2000 opts->x_flag_sanitize_recover
2001 &= ~(SANITIZE_UNDEFINED | SANITIZE_UNDEFINED_NONDEFAULT);
2002 break;
2003
2004 case OPT_fsanitize_coverage_:
2005 opts->x_flag_sanitize_coverage
2006 = parse_sanitizer_options (arg, loc, code,
2007 opts->x_flag_sanitize_coverage, value, true);
2008 break;
2009
2010 case OPT_O:
2011 case OPT_Os:
2012 case OPT_Ofast:
2013 case OPT_Og:
2014 /* Currently handled in a prescan. */
2015 break;
2016
2017 case OPT_Werror:
2018 dc->warning_as_error_requested = value;
2019 break;
2020
2021 case OPT_Werror_:
2022 if (lang_mask == CL_DRIVER)
2023 break;
2024
2025 enable_warning_as_error (arg, value, lang_mask, handlers,
2026 opts, opts_set, loc, dc);
2027 break;
2028
2029 case OPT_Wlarger_than_:
2030 opts->x_larger_than_size = value;
2031 opts->x_warn_larger_than = value != -1;
2032 break;
2033
2034 case OPT_Wfatal_errors:
2035 dc->fatal_errors = value;
2036 break;
2037
2038 case OPT_Wframe_larger_than_:
2039 opts->x_frame_larger_than_size = value;
2040 opts->x_warn_frame_larger_than = value != -1;
2041 break;
2042
2043 case OPT_Wstack_usage_:
2044 opts->x_warn_stack_usage = value;
2045 opts->x_flag_stack_usage_info = value != -1;
2046 break;
2047
2048 case OPT_Wstrict_aliasing:
2049 set_Wstrict_aliasing (opts, value);
2050 break;
2051
2052 case OPT_Wstrict_overflow:
2053 opts->x_warn_strict_overflow = (value
2054 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2055 : 0);
2056 break;
2057
2058 case OPT_Wsystem_headers:
2059 dc->dc_warn_system_headers = value;
2060 break;
2061
2062 case OPT_aux_info:
2063 opts->x_flag_gen_aux_info = 1;
2064 break;
2065
2066 case OPT_auxbase_strip:
2067 {
2068 char *tmp = xstrdup (arg);
2069 strip_off_ending (tmp, strlen (tmp));
2070 if (tmp[0])
2071 opts->x_aux_base_name = tmp;
2072 else
2073 free (tmp);
2074 }
2075 break;
2076
2077 case OPT_d:
2078 decode_d_option (arg, opts, loc, dc);
2079 break;
2080
2081 case OPT_fcall_used_:
2082 case OPT_fcall_saved_:
2083 /* Deferred. */
2084 break;
2085
2086 case OPT_fdbg_cnt_:
2087 /* Deferred. */
2088 break;
2089
2090 case OPT_fdbg_cnt_list:
2091 /* Deferred. */
2092 opts->x_exit_after_options = true;
2093 break;
2094
2095 case OPT_fdebug_prefix_map_:
2096 /* Deferred. */
2097 break;
2098
2099 case OPT_fdiagnostics_show_location_:
2100 diagnostic_prefixing_rule (dc) = (diagnostic_prefixing_rule_t) value;
2101 break;
2102
2103 case OPT_fdiagnostics_show_caret:
2104 dc->show_caret = value;
2105 break;
2106
2107 case OPT_fdiagnostics_color_:
2108 diagnostic_color_init (dc, value);
2109 break;
2110
2111 case OPT_fdiagnostics_parseable_fixits:
2112 dc->parseable_fixits_p = value;
2113 break;
2114
2115 case OPT_fdiagnostics_show_option:
2116 dc->show_option_requested = value;
2117 break;
2118
2119 case OPT_fdump_:
2120 /* Deferred. */
2121 break;
2122
2123 case OPT_ffast_math:
2124 set_fast_math_flags (opts, value);
2125 break;
2126
2127 case OPT_funsafe_math_optimizations:
2128 set_unsafe_math_optimizations_flags (opts, value);
2129 break;
2130
2131 case OPT_ffixed_:
2132 /* Deferred. */
2133 break;
2134
2135 case OPT_finline_limit_:
2136 set_param_value ("max-inline-insns-single", value / 2,
2137 opts->x_param_values, opts_set->x_param_values);
2138 set_param_value ("max-inline-insns-auto", value / 2,
2139 opts->x_param_values, opts_set->x_param_values);
2140 break;
2141
2142 case OPT_finstrument_functions_exclude_function_list_:
2143 add_comma_separated_to_vector
2144 (&opts->x_flag_instrument_functions_exclude_functions, arg);
2145 break;
2146
2147 case OPT_finstrument_functions_exclude_file_list_:
2148 add_comma_separated_to_vector
2149 (&opts->x_flag_instrument_functions_exclude_files, arg);
2150 break;
2151
2152 case OPT_fmessage_length_:
2153 pp_set_line_maximum_length (dc->printer, value);
2154 diagnostic_set_caret_max_width (dc, value);
2155 break;
2156
2157 case OPT_fopt_info:
2158 case OPT_fopt_info_:
2159 /* Deferred. */
2160 break;
2161
2162 case OPT_foffload_:
2163 {
2164 const char *p = arg;
2165 opts->x_flag_disable_hsa = true;
2166 while (*p != 0)
2167 {
2168 const char *comma = strchr (p, ',');
2169
2170 if ((strncmp (p, "disable", 7) == 0)
2171 && (p[7] == ',' || p[7] == '\0'))
2172 {
2173 opts->x_flag_disable_hsa = true;
2174 break;
2175 }
2176
2177 if ((strncmp (p, "hsa", 3) == 0)
2178 && (p[3] == ',' || p[3] == '\0'))
2179 {
2180#ifdef ENABLE_HSA
2181 opts->x_flag_disable_hsa = false;
2182#else
2183 sorry ("HSA has not been enabled during configuration");
2184#endif
2185 }
2186 if (!comma)
2187 break;
2188 p = comma + 1;
2189 }
2190 break;
2191 }
2192
2193#ifndef ACCEL_COMPILER
2194 case OPT_foffload_abi_:
2195 error_at (loc, "%<-foffload-abi%> option can be specified only for "
2196 "offload compiler");
2197 break;
2198#endif
2199
2200 case OPT_fpack_struct_:
2201 if (value <= 0 || (value & (value - 1)) || value > 16)
2202 error_at (loc,
2203 "structure alignment must be a small power of two, not %d",
2204 value);
2205 else
2206 opts->x_initial_max_fld_align = value;
2207 break;
2208
2209 case OPT_fplugin_:
2210 case OPT_fplugin_arg_:
2211 /* Deferred. */
2212 break;
2213
2214 case OPT_fprofile_use_:
2215 opts->x_profile_data_prefix = xstrdup (arg);
2216 opts->x_flag_profile_use = true;
2217 value = true;
2218 /* No break here - do -fprofile-use processing. */
2219 /* FALLTHRU */
2220 case OPT_fprofile_use:
2221 enable_fdo_optimizations (opts, opts_set, value);
2222 if (!opts_set->x_flag_profile_reorder_functions)
2223 opts->x_flag_profile_reorder_functions = value;
2224 /* Indirect call profiling should do all useful transformations
2225 speculative devirtualization does. */
2226 if (!opts_set->x_flag_devirtualize_speculatively
2227 && opts->x_flag_value_profile_transformations)
2228 opts->x_flag_devirtualize_speculatively = false;
2229 break;
2230
2231 case OPT_fauto_profile_:
2232 opts->x_auto_profile_file = xstrdup (arg);
2233 opts->x_flag_auto_profile = true;
2234 value = true;
2235 /* No break here - do -fauto-profile processing. */
2236 /* FALLTHRU */
2237 case OPT_fauto_profile:
2238 enable_fdo_optimizations (opts, opts_set, value);
2239 if (!opts_set->x_flag_profile_correction)
2240 opts->x_flag_profile_correction = value;
2241 maybe_set_param_value (
2242 PARAM_EARLY_INLINER_MAX_ITERATIONS, 10,
2243 opts->x_param_values, opts_set->x_param_values);
2244 break;
2245
2246 case OPT_fprofile_generate_:
2247 opts->x_profile_data_prefix = xstrdup (arg);
2248 value = true;
2249 /* No break here - do -fprofile-generate processing. */
2250 /* FALLTHRU */
2251 case OPT_fprofile_generate:
2252 if (!opts_set->x_profile_arc_flag)
2253 opts->x_profile_arc_flag = value;
2254 if (!opts_set->x_flag_profile_values)
2255 opts->x_flag_profile_values = value;
2256 if (!opts_set->x_flag_inline_functions)
2257 opts->x_flag_inline_functions = value;
2258 if (!opts_set->x_flag_ipa_bit_cp)
2259 opts->x_flag_ipa_bit_cp = value;
2260 /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
2261 quadratic. Disable the pass until better memory representation
2262 is done. */
2263 if (!opts_set->x_flag_ipa_reference)
2264 opts->x_flag_ipa_reference = false;
2265 break;
2266
2267 case OPT_fpatchable_function_entry_:
2268 {
2269 char *patch_area_arg = xstrdup (arg);
2270 char *comma = strchr (patch_area_arg, ',');
2271 if (comma)
2272 {
2273 *comma = '\0';
2274 function_entry_patch_area_size =
2275 integral_argument (patch_area_arg);
2276 function_entry_patch_area_start =
2277 integral_argument (comma + 1);
2278 }
2279 else
2280 {
2281 function_entry_patch_area_size =
2282 integral_argument (patch_area_arg);
2283 function_entry_patch_area_start = 0;
2284 }
2285 if (function_entry_patch_area_size < 0
2286 || function_entry_patch_area_start < 0
2287 || function_entry_patch_area_size
2288 < function_entry_patch_area_start)
2289 error ("invalid arguments for %<-fpatchable_function_entry%>");
2290 free (patch_area_arg);
2291 }
2292 break;
2293
2294 case OPT_ftree_vectorize:
2295 /* Automatically sets -ftree-loop-vectorize and
2296 -ftree-slp-vectorize. Nothing more to do here. */
2297 break;
2298 case OPT_fshow_column:
2299 dc->show_column = value;
2300 break;
2301
2302 case OPT_frandom_seed:
2303 /* The real switch is -fno-random-seed. */
2304 if (value)
2305 return false;
2306 /* Deferred. */
2307 break;
2308
2309 case OPT_frandom_seed_:
2310 /* Deferred. */
2311 break;
2312
2313 case OPT_fsched_verbose_:
2314#ifdef INSN_SCHEDULING
2315 /* Handled with Var in common.opt. */
2316 break;
2317#else
2318 return false;
2319#endif
2320
2321 case OPT_fsched_stalled_insns_:
2322 opts->x_flag_sched_stalled_insns = value;
2323 if (opts->x_flag_sched_stalled_insns == 0)
2324 opts->x_flag_sched_stalled_insns = -1;
2325 break;
2326
2327 case OPT_fsched_stalled_insns_dep_:
2328 opts->x_flag_sched_stalled_insns_dep = value;
2329 break;
2330
2331 case OPT_fstack_check_:
2332 if (!strcmp (arg, "no"))
2333 opts->x_flag_stack_check = NO_STACK_CHECK;
2334 else if (!strcmp (arg, "generic"))
2335 /* This is the old stack checking method. */
2336 opts->x_flag_stack_check = STACK_CHECK_BUILTIN
2337 ? FULL_BUILTIN_STACK_CHECK
2338 : GENERIC_STACK_CHECK;
2339 else if (!strcmp (arg, "specific"))
2340 /* This is the new stack checking method. */
2341 opts->x_flag_stack_check = STACK_CHECK_BUILTIN
2342 ? FULL_BUILTIN_STACK_CHECK
2343 : STACK_CHECK_STATIC_BUILTIN
2344 ? STATIC_BUILTIN_STACK_CHECK
2345 : GENERIC_STACK_CHECK;
2346 else
2347 warning_at (loc, 0, "unknown stack check parameter %qs", arg);
2348 break;
2349
2350 case OPT_fstack_limit:
2351 /* The real switch is -fno-stack-limit. */
2352 if (value)
2353 return false;
2354 /* Deferred. */
2355 break;
2356
2357 case OPT_fstack_limit_register_:
2358 case OPT_fstack_limit_symbol_:
2359 /* Deferred. */
2360 break;
2361
2362 case OPT_fstack_usage:
2363 opts->x_flag_stack_usage = value;
2364 opts->x_flag_stack_usage_info = value != 0;
2365 break;
2366
2367 case OPT_g:
2368 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg, opts, opts_set,
2369 loc);
2370 break;
2371
2372 case OPT_gdwarf:
2373 if (arg && strlen (arg) != 0)
2374 {
2375 error_at (loc, "%<-gdwarf%s%> is ambiguous; "
2376 "use %<-gdwarf-%s%> for DWARF version "
2377 "or %<-gdwarf -g%s%> for debug level", arg, arg, arg);
2378 break;
2379 }
2380 else
2381 value = opts->x_dwarf_version;
2382
2383 /* FALLTHRU */
2384 case OPT_gdwarf_:
2385 if (value < 2 || value > 5)
2386 error_at (loc, "dwarf version %d is not supported", value);
2387 else
2388 opts->x_dwarf_version = value;
2389 set_debug_level (DWARF2_DEBUG, false, "", opts, opts_set, loc);
2390 break;
2391
2392 case OPT_gsplit_dwarf:
2393 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, "", opts, opts_set,
2394 loc);
2395 break;
2396
2397 case OPT_ggdb:
2398 set_debug_level (NO_DEBUG, 2, arg, opts, opts_set, loc);
2399 break;
2400
2401 case OPT_gstabs:
2402 case OPT_gstabs_:
2403 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg, opts, opts_set,
2404 loc);
2405 break;
2406
2407 case OPT_gvms:
2408 set_debug_level (VMS_DEBUG, false, arg, opts, opts_set, loc);
2409 break;
2410
2411 case OPT_gxcoff:
2412 case OPT_gxcoff_:
2413 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg, opts, opts_set,
2414 loc);
2415 break;
2416
2417 case OPT_gz:
2418 case OPT_gz_:
2419 /* Handled completely via specs. */
2420 break;
2421
2422 case OPT_pedantic_errors:
2423 dc->pedantic_errors = 1;
2424 control_warning_option (OPT_Wpedantic, DK_ERROR, NULL, value,
2425 loc, lang_mask,
2426 handlers, opts, opts_set,
2427 dc);
2428 break;
2429
2430 case OPT_flto:
2431 opts->x_flag_lto = value ? "" : NULL;
2432 break;
2433
2434 case OPT_w:
2435 dc->dc_inhibit_warnings = true;
2436 break;
2437
2438 case OPT_fmax_errors_:
2439 dc->max_errors = value;
2440 break;
2441
2442 case OPT_fuse_ld_bfd:
2443 case OPT_fuse_ld_gold:
2444 case OPT_fuse_linker_plugin:
2445 /* No-op. Used by the driver and passed to us because it starts with f.*/
2446 break;
2447
2448 case OPT_fwrapv:
2449 if (value)
2450 opts->x_flag_trapv = 0;
2451 break;
2452
2453 case OPT_ftrapv:
2454 if (value)
2455 opts->x_flag_wrapv = 0;
2456 break;
2457
2458 case OPT_fipa_icf:
2459 opts->x_flag_ipa_icf_functions = value;
2460 opts->x_flag_ipa_icf_variables = value;
2461 break;
2462
2463 default:
2464 /* If the flag was handled in a standard way, assume the lack of
2465 processing here is intentional. */
2466 gcc_assert (option_flag_var (scode, opts));
2467 break;
2468 }
2469
2470 common_handle_option_auto (opts, opts_set, decoded, lang_mask, kind,
2471 loc, handlers, dc);
2472 return true;
2473}
2474
2475/* Handle --param NAME=VALUE. */
2476static void
2477handle_param (struct gcc_options *opts, struct gcc_options *opts_set,
2478 location_t loc, const char *carg)
2479{
2480 char *equal, *arg;
2481 int value;
2482
2483 arg = xstrdup (carg);
2484 equal = strchr (arg, '=');
2485 if (!equal)
2486 error_at (loc, "%s: --param arguments should be of the form NAME=VALUE",
2487 arg);
2488 else
2489 {
2490 *equal = '\0';
2491
2492 enum compiler_param index;
2493 if (!find_param (arg, &index))
2494 {
2495 const char *suggestion = find_param_fuzzy (arg);
2496 if (suggestion)
2497 error_at (loc, "invalid --param name %qs; did you mean %qs?",
2498 arg, suggestion);
2499 else
2500 error_at (loc, "invalid --param name %qs", arg);
2501 }
2502 else
2503 {
2504 if (!param_string_value_p (index, equal + 1, &value))
2505 value = integral_argument (equal + 1);
2506
2507 if (value == -1)
2508 error_at (loc, "invalid --param value %qs", equal + 1);
2509 else
2510 set_param_value (arg, value,
2511 opts->x_param_values, opts_set->x_param_values);
2512 }
2513 }
2514
2515 free (arg);
2516}
2517
2518/* Used to set the level of strict aliasing warnings in OPTS,
2519 when no level is specified (i.e., when -Wstrict-aliasing, and not
2520 -Wstrict-aliasing=level was given).
2521 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2522 and 0 otherwise. After calling this function, wstrict_aliasing will be
2523 set to the default value of -Wstrict_aliasing=level, currently 3. */
2524static void
2525set_Wstrict_aliasing (struct gcc_options *opts, int onoff)
2526{
2527 gcc_assert (onoff == 0 || onoff == 1);
2528 if (onoff != 0)
2529 opts->x_warn_strict_aliasing = 3;
2530 else
2531 opts->x_warn_strict_aliasing = 0;
2532}
2533
2534/* The following routines are useful in setting all the flags that
2535 -ffast-math and -fno-fast-math imply. */
2536static void
2537set_fast_math_flags (struct gcc_options *opts, int set)
2538{
2539 if (!opts->frontend_set_flag_unsafe_math_optimizations)
2540 {
2541 opts->x_flag_unsafe_math_optimizations = set;
2542 set_unsafe_math_optimizations_flags (opts, set);
2543 }
2544 if (!opts->frontend_set_flag_finite_math_only)
2545 opts->x_flag_finite_math_only = set;
2546 if (!opts->frontend_set_flag_errno_math)
2547 opts->x_flag_errno_math = !set;
2548 if (set)
2549 {
2550 if (opts->frontend_set_flag_excess_precision_cmdline
2551 == EXCESS_PRECISION_DEFAULT)
2552 opts->x_flag_excess_precision_cmdline
2553 = set ? EXCESS_PRECISION_FAST : EXCESS_PRECISION_DEFAULT;
2554 if (!opts->frontend_set_flag_signaling_nans)
2555 opts->x_flag_signaling_nans = 0;
2556 if (!opts->frontend_set_flag_rounding_math)
2557 opts->x_flag_rounding_math = 0;
2558 if (!opts->frontend_set_flag_cx_limited_range)
2559 opts->x_flag_cx_limited_range = 1;
2560 }
2561}
2562
2563/* When -funsafe-math-optimizations is set the following
2564 flags are set as well. */
2565static void
2566set_unsafe_math_optimizations_flags (struct gcc_options *opts, int set)
2567{
2568 if (!opts->frontend_set_flag_trapping_math)
2569 opts->x_flag_trapping_math = !set;
2570 if (!opts->frontend_set_flag_signed_zeros)
2571 opts->x_flag_signed_zeros = !set;
2572 if (!opts->frontend_set_flag_associative_math)
2573 opts->x_flag_associative_math = set;
2574 if (!opts->frontend_set_flag_reciprocal_math)
2575 opts->x_flag_reciprocal_math = set;
2576}
2577
2578/* Return true iff flags in OPTS are set as if -ffast-math. */
2579bool
2580fast_math_flags_set_p (const struct gcc_options *opts)
2581{
2582 return (!opts->x_flag_trapping_math
2583 && opts->x_flag_unsafe_math_optimizations
2584 && opts->x_flag_finite_math_only
2585 && !opts->x_flag_signed_zeros
2586 && !opts->x_flag_errno_math
2587 && opts->x_flag_excess_precision_cmdline
2588 == EXCESS_PRECISION_FAST);
2589}
2590
2591/* Return true iff flags are set as if -ffast-math but using the flags stored
2592 in the struct cl_optimization structure. */
2593bool
2594fast_math_flags_struct_set_p (struct cl_optimization *opt)
2595{
2596 return (!opt->x_flag_trapping_math
2597 && opt->x_flag_unsafe_math_optimizations
2598 && opt->x_flag_finite_math_only
2599 && !opt->x_flag_signed_zeros
2600 && !opt->x_flag_errno_math);
2601}
2602
2603/* Handle a debug output -g switch for options OPTS
2604 (OPTS_SET->x_write_symbols storing whether a debug type was passed
2605 explicitly), location LOC. EXTENDED is true or false to support
2606 extended output (2 is special and means "-ggdb" was given). */
2607static void
2608set_debug_level (enum debug_info_type type, int extended, const char *arg,
2609 struct gcc_options *opts, struct gcc_options *opts_set,
2610 location_t loc)
2611{
2612 opts->x_use_gnu_debug_info_extensions = extended;
2613
2614 if (type == NO_DEBUG)
2615 {
2616 if (opts->x_write_symbols == NO_DEBUG)
2617 {
2618 opts->x_write_symbols = PREFERRED_DEBUGGING_TYPE;
2619
2620 if (extended == 2)
2621 {
2622#if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
2623 opts->x_write_symbols = DWARF2_DEBUG;
2624#elif defined DBX_DEBUGGING_INFO
2625 opts->x_write_symbols = DBX_DEBUG;
2626#endif
2627 }
2628
2629 if (opts->x_write_symbols == NO_DEBUG)
2630 warning_at (loc, 0, "target system does not support debug output");
2631 }
2632 }
2633 else
2634 {
2635 /* Does it conflict with an already selected type? */
2636 if (opts_set->x_write_symbols != NO_DEBUG
2637 && opts->x_write_symbols != NO_DEBUG
2638 && type != opts->x_write_symbols)
2639 error_at (loc, "debug format %qs conflicts with prior selection",
2640 debug_type_names[type]);
2641 opts->x_write_symbols = type;
2642 opts_set->x_write_symbols = type;
2643 }
2644
2645 /* A debug flag without a level defaults to level 2.
2646 If off or at level 1, set it to level 2, but if already
2647 at level 3, don't lower it. */
2648 if (*arg == '\0')
2649 {
2650 if (opts->x_debug_info_level < DINFO_LEVEL_NORMAL)
2651 opts->x_debug_info_level = DINFO_LEVEL_NORMAL;
2652 }
2653 else
2654 {
2655 int argval = integral_argument (arg);
2656 if (argval == -1)
2657 error_at (loc, "unrecognized debug output level %qs", arg);
2658 else if (argval > 3)
2659 error_at (loc, "debug output level %qs is too high", arg);
2660 else
2661 opts->x_debug_info_level = (enum debug_info_levels) argval;
2662 }
2663}
2664
2665/* Arrange to dump core on error for diagnostic context DC. (The
2666 regular error message is still printed first, except in the case of
2667 abort ().) */
2668
2669static void
2670setup_core_dumping (diagnostic_context *dc)
2671{
2672#ifdef SIGABRT
2673 signal (SIGABRT, SIG_DFL);
2674#endif
2675#if defined(HAVE_SETRLIMIT)
2676 {
2677 struct rlimit rlim;
2678 if (getrlimit (RLIMIT_CORE, &rlim) != 0)
2679 fatal_error (input_location, "getting core file size maximum limit: %m");
2680 rlim.rlim_cur = rlim.rlim_max;
2681 if (setrlimit (RLIMIT_CORE, &rlim) != 0)
2682 fatal_error (input_location,
2683 "setting core file size limit to maximum: %m");
2684 }
2685#endif
2686 diagnostic_abort_on_error (dc);
2687}
2688
2689/* Parse a -d<ARG> command line switch for OPTS, location LOC,
2690 diagnostic context DC. */
2691
2692static void
2693decode_d_option (const char *arg, struct gcc_options *opts,
2694 location_t loc, diagnostic_context *dc)
2695{
2696 int c;
2697
2698 while (*arg)
2699 switch (c = *arg++)
2700 {
2701 case 'A':
2702 opts->x_flag_debug_asm = 1;
2703 break;
2704 case 'p':
2705 opts->x_flag_print_asm_name = 1;
2706 break;
2707 case 'P':
2708 opts->x_flag_dump_rtl_in_asm = 1;
2709 opts->x_flag_print_asm_name = 1;
2710 break;
2711 case 'x':
2712 opts->x_rtl_dump_and_exit = 1;
2713 break;
2714 case 'D': /* These are handled by the preprocessor. */
2715 case 'I':
2716 case 'M':
2717 case 'N':
2718 case 'U':
2719 break;
2720 case 'H':
2721 setup_core_dumping (dc);
2722 break;
2723 case 'a':
2724 opts->x_flag_dump_all_passed = true;
2725 break;
2726
2727 default:
2728 warning_at (loc, 0, "unrecognized gcc debugging option: %c", c);
2729 break;
2730 }
2731}
2732
2733/* Enable (or disable if VALUE is 0) a warning option ARG (language
2734 mask LANG_MASK, option handlers HANDLERS) as an error for option
2735 structures OPTS and OPTS_SET, diagnostic context DC (possibly
2736 NULL), location LOC. This is used by -Werror=. */
2737
2738static void
2739enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
2740 const struct cl_option_handlers *handlers,
2741 struct gcc_options *opts,
2742 struct gcc_options *opts_set,
2743 location_t loc, diagnostic_context *dc)
2744{
2745 char *new_option;
2746 int option_index;
2747
2748 new_option = XNEWVEC (char, strlen (arg) + 2);
2749 new_option[0] = 'W';
2750 strcpy (new_option + 1, arg);
2751 option_index = find_opt (new_option, lang_mask);
2752 if (option_index == OPT_SPECIAL_unknown)
2753 error_at (loc, "-Werror=%s: no option -%s", arg, new_option);
2754 else if (!(cl_options[option_index].flags & CL_WARNING))
2755 error_at (loc, "-Werror=%s: -%s is not an option that controls warnings",
2756 arg, new_option);
2757 else
2758 {
2759 const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
2760 const char *arg = NULL;
2761
2762 if (cl_options[option_index].flags & CL_JOINED)
2763 arg = new_option + cl_options[option_index].opt_len;
2764 control_warning_option (option_index, (int) kind, arg, value,
2765 loc, lang_mask,
2766 handlers, opts, opts_set, dc);
2767 }
2768 free (new_option);
2769}
2770
2771/* Return malloced memory for the name of the option OPTION_INDEX
2772 which enabled a diagnostic (context CONTEXT), originally of type
2773 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2774 as -Werror. */
2775
2776char *
2777option_name (diagnostic_context *context, int option_index,
2778 diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
2779{
2780 if (option_index)
2781 {
2782 /* A warning classified as an error. */
2783 if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
2784 && diag_kind == DK_ERROR)
2785 return concat (cl_options[OPT_Werror_].opt_text,
2786 /* Skip over "-W". */
2787 cl_options[option_index].opt_text + 2,
2788 NULL);
2789 /* A warning with option. */
2790 else
2791 return xstrdup (cl_options[option_index].opt_text);
2792 }
2793 /* A warning without option classified as an error. */
2794 else if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
2795 || diag_kind == DK_WARNING)
2796 && context->warning_as_error_requested)
2797 return xstrdup (cl_options[OPT_Werror].opt_text);
2798 else
2799 return NULL;
2800}
2801