?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
usr.sbin/makefs/hammer2: Remove redundant hammer2_inode_modify()
[dragonfly.git] / contrib / gcc-8.0 / gcc / opts.c
blob28030881e938a7c628a08dbdb36e7f2461e3c38c
1 /* Command line option handling.
2 Copyright (C) 2002-2018 Free Software Foundation, Inc.
3 Contributed by Neil Booth.
4
5 This file is part of GCC.
6
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
10 version.
11
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
15 for more details.
16
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/>. */
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
35 static void set_Wstrict_aliasing (struct gcc_options *opts, int onoff);
36
37 /* Indexed by enum debug_info_type. */
38 const 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
50 void
51 set_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
144 void
145 strip_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. */
160 int
161 base_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. */
185 static const char undocumented_msg[] = N_("This option lacks documentation.");
186 static const char use_diagnosed_msg[] = N_("Uses of this option are diagnosed.");
187
188 typedef char *char_p; /* For DEF_VEC_P. */
189
190 static void handle_param (struct gcc_options *opts,
191 struct gcc_options *opts_set, location_t loc,
192 const char *carg);
193 static void set_debug_level (enum debug_info_type type, int extended,
194 const char *arg, struct gcc_options *opts,
195 struct gcc_options *opts_set,
196 location_t loc);
197 static void set_fast_math_flags (struct gcc_options *opts, int set);
198 static void decode_d_option (const char *arg, struct gcc_options *opts,
199 location_t loc, diagnostic_context *dc);
200 static void set_unsafe_math_optimizations_flags (struct gcc_options *opts,
201 int set);
202 static void enable_warning_as_error (const char *arg, int value,
203 unsigned int lang_mask,
204 const struct cl_option_handlers *handlers,
205 struct gcc_options *opts,
206 struct gcc_options *opts_set,
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
213 bool
214 target_handle_option (struct gcc_options *opts,
215 struct gcc_options *opts_set,
216 const struct cl_decoded_option *decoded,
217 unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
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
229 static void
230 add_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
272 void
273 init_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
280 void
281 init_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
320 void
321 finalize_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
331 static void
332 maybe_default_option (struct gcc_options *opts,
333 struct gcc_options *opts_set,
334 const struct default_options *default_opt,
335 int level, bool size, bool fast, bool debug,
336 unsigned int lang_mask,
337 const struct cl_option_handlers *handlers,
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
420 static void
421 maybe_default_options (struct gcc_options *opts,
422 struct gcc_options *opts_set,
423 const struct default_options *default_opts,
424 int level, bool size, bool fast, bool debug,
425 unsigned int lang_mask,
426 const struct cl_option_handlers *handlers,
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
440 static 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. */
556 void
557 default_options_optimization (struct gcc_options *opts,
558 struct gcc_options *opts_set,
559 struct cl_decoded_option *decoded_options,
560 unsigned int decoded_options_count,
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)
661 : default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP) / 10,
662 opts->x_param_values, opts_set->x_param_values);
663
664 /* For -O1 reduce the maximum number of active local stores for RTL DSE
665 since this can consume huge amounts of memory (PR89115). */
666 maybe_set_param_value
667 (PARAM_MAX_DSE_ACTIVE_LOCAL_STORES,
668 opt2 ? default_param_value (PARAM_MAX_DSE_ACTIVE_LOCAL_STORES)
669 : default_param_value (PARAM_MAX_DSE_ACTIVE_LOCAL_STORES) / 10,
670 opts->x_param_values, opts_set->x_param_values);
671
672 /* At -Ofast, allow store motion to introduce potential race conditions. */
673 maybe_set_param_value
674 (PARAM_ALLOW_STORE_DATA_RACES,
675 opts->x_optimize_fast ? 1
676 : default_param_value (PARAM_ALLOW_STORE_DATA_RACES),
677 opts->x_param_values, opts_set->x_param_values);
678
679 if (opts->x_optimize_size)
680 /* We want to crossjump as much as possible. */
681 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS, 1,
682 opts->x_param_values, opts_set->x_param_values);
683 else
684 maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS,
685 default_param_value (PARAM_MIN_CROSSJUMP_INSNS),
686 opts->x_param_values, opts_set->x_param_values);
687
688 /* Restrict the amount of work combine does at -Og while retaining
689 most of its useful transforms. */
690 if (opts->x_optimize_debug)
691 maybe_set_param_value (PARAM_MAX_COMBINE_INSNS, 2,
692 opts->x_param_values, opts_set->x_param_values);
693
694 /* Allow default optimizations to be specified on a per-machine basis. */
695 maybe_default_options (opts, opts_set,
696 targetm_common.option_optimization_table,
697 opts->x_optimize, opts->x_optimize_size,
698 opts->x_optimize_fast, opts->x_optimize_debug,
699 lang_mask, handlers, loc, dc);
700 }
701
702 /* After all options at LOC have been read into OPTS and OPTS_SET,
703 finalize settings of those options and diagnose incompatible
704 combinations. */
705 void
706 finish_options (struct gcc_options *opts, struct gcc_options *opts_set,
707 location_t loc)
708 {
709 enum unwind_info_type ui_except;
710
711 if (opts->x_dump_base_name
712 && ! opts->x_dump_base_name_prefixed)
713 {
714 const char *sep = opts->x_dump_base_name;
715
716 for (; *sep; sep++)
717 if (IS_DIR_SEPARATOR (*sep))
718 break;
719
720 if (*sep)
721 /* If dump_base_path contains subdirectories, don't prepend
722 anything. */;
723 else if (opts->x_dump_dir_name)
724 /* We have a DUMP_DIR_NAME, prepend that. */
725 opts->x_dump_base_name = opts_concat (opts->x_dump_dir_name,
726 opts->x_dump_base_name, NULL);
727 else if (opts->x_aux_base_name
728 && strcmp (opts->x_aux_base_name, HOST_BIT_BUCKET) != 0)
729 /* AUX_BASE_NAME is set and is not the bit bucket. If it
730 contains a directory component, prepend those directories.
731 Typically this places things in the same directory as the
732 object file. */
733 {
734 const char *aux_base;
735
736 base_of_path (opts->x_aux_base_name, &aux_base);
737 if (opts->x_aux_base_name != aux_base)
738 {
739 int dir_len = aux_base - opts->x_aux_base_name;
740 char *new_dump_base_name
741 = XOBNEWVEC (&opts_obstack, char,
742 strlen (opts->x_dump_base_name) + dir_len + 1);
743
744 /* Copy directory component from OPTS->X_AUX_BASE_NAME. */
745 memcpy (new_dump_base_name, opts->x_aux_base_name, dir_len);
746 /* Append existing OPTS->X_DUMP_BASE_NAME. */
747 strcpy (new_dump_base_name + dir_len, opts->x_dump_base_name);
748 opts->x_dump_base_name = new_dump_base_name;
749 }
750 }
751
752 /* It is definitely prefixed now. */
753 opts->x_dump_base_name_prefixed = true;
754 }
755
756 /* Handle related options for unit-at-a-time, toplevel-reorder, and
757 section-anchors. */
758 if (!opts->x_flag_unit_at_a_time)
759 {
760 if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
761 error_at (loc, "section anchors must be disabled when unit-at-a-time "
762 "is disabled");
763 opts->x_flag_section_anchors = 0;
764 if (opts->x_flag_toplevel_reorder == 1)
765 error_at (loc, "toplevel reorder must be disabled when unit-at-a-time "
766 "is disabled");
767 opts->x_flag_toplevel_reorder = 0;
768 }
769
770 /* -fself-test depends on the state of the compiler prior to
771 compiling anything. Ideally it should be run on an empty source
772 file. However, in case we get run with actual source, assume
773 -fsyntax-only which will inhibit any compiler initialization
774 which may confuse the self tests. */
775 if (opts->x_flag_self_test)
776 opts->x_flag_syntax_only = 1;
777
778 if (opts->x_flag_tm && opts->x_flag_non_call_exceptions)
779 sorry ("transactional memory is not supported with non-call exceptions");
780
781 /* Unless the user has asked for section anchors, we disable toplevel
782 reordering at -O0 to disable transformations that might be surprising
783 to end users and to get -fno-toplevel-reorder tested. */
784 if (!opts->x_optimize
785 && opts->x_flag_toplevel_reorder == 2
786 && !(opts->x_flag_section_anchors && opts_set->x_flag_section_anchors))
787 {
788 opts->x_flag_toplevel_reorder = 0;
789 opts->x_flag_section_anchors = 0;
790 }
791 if (!opts->x_flag_toplevel_reorder)
792 {
793 if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
794 error_at (loc, "section anchors must be disabled when toplevel reorder"
795 " is disabled");
796 opts->x_flag_section_anchors = 0;
797 }
798
799 if (!opts->x_flag_opts_finished)
800 {
801 /* We initialize opts->x_flag_pie to -1 so that targets can set a
802 default value. */
803 if (opts->x_flag_pie == -1)
804 {
805 /* We initialize opts->x_flag_pic to -1 so that we can tell if
806 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
807 if (opts->x_flag_pic == -1)
808 opts->x_flag_pie = DEFAULT_FLAG_PIE;
809 else
810 opts->x_flag_pie = 0;
811 }
812 /* If -fPIE or -fpie is used, turn on PIC. */
813 if (opts->x_flag_pie)
814 opts->x_flag_pic = opts->x_flag_pie;
815 else if (opts->x_flag_pic == -1)
816 opts->x_flag_pic = 0;
817 if (opts->x_flag_pic && !opts->x_flag_pie)
818 opts->x_flag_shlib = 1;
819 opts->x_flag_opts_finished = true;
820 }
821
822 /* We initialize opts->x_flag_stack_protect to -1 so that targets
823 can set a default value. */
824 if (opts->x_flag_stack_protect == -1)
825 opts->x_flag_stack_protect = DEFAULT_FLAG_SSP;
826
827 if (opts->x_optimize == 0)
828 {
829 /* Inlining does not work if not optimizing,
830 so force it not to be done. */
831 opts->x_warn_inline = 0;
832 opts->x_flag_no_inline = 1;
833 }
834
835 /* The optimization to partition hot and cold basic blocks into separate
836 sections of the .o and executable files does not work (currently)
837 with exception handling. This is because there is no support for
838 generating unwind info. If opts->x_flag_exceptions is turned on
839 we need to turn off the partitioning optimization. */
840
841 ui_except = targetm_common.except_unwind_info (opts);
842
843 if (opts->x_flag_exceptions
844 && opts->x_flag_reorder_blocks_and_partition
845 && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))
846 {
847 if (opts_set->x_flag_reorder_blocks_and_partition)
848 inform (loc,
849 "%<-freorder-blocks-and-partition%> does not work "
850 "with exceptions on this architecture");
851 opts->x_flag_reorder_blocks_and_partition = 0;
852 opts->x_flag_reorder_blocks = 1;
853 }
854
855 /* If user requested unwind info, then turn off the partitioning
856 optimization. */
857
858 if (opts->x_flag_unwind_tables
859 && !targetm_common.unwind_tables_default
860 && opts->x_flag_reorder_blocks_and_partition
861 && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))
862 {
863 if (opts_set->x_flag_reorder_blocks_and_partition)
864 inform (loc,
865 "%<-freorder-blocks-and-partition%> does not support "
866 "unwind info on this architecture");
867 opts->x_flag_reorder_blocks_and_partition = 0;
868 opts->x_flag_reorder_blocks = 1;
869 }
870
871 /* If the target requested unwind info, then turn off the partitioning
872 optimization with a different message. Likewise, if the target does not
873 support named sections. */
874
875 if (opts->x_flag_reorder_blocks_and_partition
876 && (!targetm_common.have_named_sections
877 || (opts->x_flag_unwind_tables
878 && targetm_common.unwind_tables_default
879 && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))))
880 {
881 if (opts_set->x_flag_reorder_blocks_and_partition)
882 inform (loc,
883 "%<-freorder-blocks-and-partition%> does not work "
884 "on this architecture");
885 opts->x_flag_reorder_blocks_and_partition = 0;
886 opts->x_flag_reorder_blocks = 1;
887 }
888
889
890 /* Pipelining of outer loops is only possible when general pipelining
891 capabilities are requested. */
892 if (!opts->x_flag_sel_sched_pipelining)
893 opts->x_flag_sel_sched_pipelining_outer_loops = 0;
894
895 if (opts->x_flag_conserve_stack)
896 {
897 maybe_set_param_value (PARAM_LARGE_STACK_FRAME, 100,
898 opts->x_param_values, opts_set->x_param_values);
899 maybe_set_param_value (PARAM_STACK_FRAME_GROWTH, 40,
900 opts->x_param_values, opts_set->x_param_values);
901 }
902
903 if (opts->x_flag_lto)
904 {
905 #ifdef ENABLE_LTO
906 opts->x_flag_generate_lto = 1;
907
908 /* When generating IL, do not operate in whole-program mode.
909 Otherwise, symbols will be privatized too early, causing link
910 errors later. */
911 opts->x_flag_whole_program = 0;
912 #else
913 error_at (loc, "LTO support has not been enabled in this configuration");
914 #endif
915 if (!opts->x_flag_fat_lto_objects
916 && (!HAVE_LTO_PLUGIN
917 || (opts_set->x_flag_use_linker_plugin
918 && !opts->x_flag_use_linker_plugin)))
919 {
920 if (opts_set->x_flag_fat_lto_objects)
921 error_at (loc, "%<-fno-fat-lto-objects%> are supported only with "
922 "linker plugin");
923 opts->x_flag_fat_lto_objects = 1;
924 }
925
926 /* -gsplit-dwarf isn't compatible with LTO, see PR88389. */
927 if (opts->x_dwarf_split_debug_info)
928 {
929 inform (loc, "%<-gsplit-dwarf%> is not supported with LTO,"
930 " disabling");
931 opts->x_dwarf_split_debug_info = 0;
932 }
933 }
934
935 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
936 default value if they choose based on other options. */
937 if (opts->x_flag_split_stack == -1)
938 opts->x_flag_split_stack = 0;
939 else if (opts->x_flag_split_stack)
940 {
941 if (!targetm_common.supports_split_stack (true, opts))
942 {
943 error_at (loc, "%<-fsplit-stack%> is not supported by "
944 "this compiler configuration");
945 opts->x_flag_split_stack = 0;
946 }
947 }
948
949 /* If stack splitting is turned on, and the user did not explicitly
950 request function partitioning, turn off partitioning, as it
951 confuses the linker when trying to handle partitioned split-stack
952 code that calls a non-split-stack functions. But if partitioning
953 was turned on explicitly just hope for the best. */
954 if (opts->x_flag_split_stack
955 && opts->x_flag_reorder_blocks_and_partition
956 && !opts_set->x_flag_reorder_blocks_and_partition)
957 opts->x_flag_reorder_blocks_and_partition = 0;
958
959 if (opts->x_flag_reorder_blocks_and_partition
960 && !opts_set->x_flag_reorder_functions)
961 opts->x_flag_reorder_functions = 1;
962
963 /* Tune vectorization related parametees according to cost model. */
964 if (opts->x_flag_vect_cost_model == VECT_COST_MODEL_CHEAP)
965 {
966 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS,
967 6, opts->x_param_values, opts_set->x_param_values);
968 maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS,
969 0, opts->x_param_values, opts_set->x_param_values);
970 maybe_set_param_value (PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT,
971 0, opts->x_param_values, opts_set->x_param_values);
972 }
973
974 /* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
975 is disabled. */
976 if ((!opts->x_flag_tree_loop_vectorize && !opts->x_flag_tree_slp_vectorize)
977 || !opts->x_flag_tree_loop_if_convert)
978 maybe_set_param_value (PARAM_MAX_STORES_TO_SINK, 0,
979 opts->x_param_values, opts_set->x_param_values);
980
981 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
982 if (opts->x_dwarf_split_debug_info)
983 opts->x_debug_generate_pub_sections = 2;
984
985 if ((opts->x_flag_sanitize
986 & (SANITIZE_USER_ADDRESS | SANITIZE_KERNEL_ADDRESS)) == 0)
987 {
988 if (opts->x_flag_sanitize & SANITIZE_POINTER_COMPARE)
989 error_at (loc,
990 "%<-fsanitize=pointer-compare%> must be combined with "
991 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
992 if (opts->x_flag_sanitize & SANITIZE_POINTER_SUBTRACT)
993 error_at (loc,
994 "%<-fsanitize=pointer-subtract%> must be combined with "
995 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
996 }
997
998 /* Userspace and kernel ASan conflict with each other. */
999 if ((opts->x_flag_sanitize & SANITIZE_USER_ADDRESS)
1000 && (opts->x_flag_sanitize & SANITIZE_KERNEL_ADDRESS))
1001 error_at (loc,
1002 "%<-fsanitize=address%> is incompatible with "
1003 "%<-fsanitize=kernel-address%>");
1004
1005 /* And with TSan. */
1006 if ((opts->x_flag_sanitize & SANITIZE_ADDRESS)
1007 && (opts->x_flag_sanitize & SANITIZE_THREAD))
1008 error_at (loc,
1009 "%<-fsanitize=address%> and %<-fsanitize=kernel-address%> "
1010 "are incompatible with %<-fsanitize=thread%>");
1011
1012 if ((opts->x_flag_sanitize & SANITIZE_LEAK)
1013 && (opts->x_flag_sanitize & SANITIZE_THREAD))
1014 error_at (loc,
1015 "%<-fsanitize=leak%> is incompatible with %<-fsanitize=thread%>");
1016
1017 /* Check error recovery for -fsanitize-recover option. */
1018 for (int i = 0; sanitizer_opts[i].name != NULL; ++i)
1019 if ((opts->x_flag_sanitize_recover & sanitizer_opts[i].flag)
1020 && !sanitizer_opts[i].can_recover)
1021 error_at (loc, "%<-fsanitize-recover=%s%> is not supported",
1022 sanitizer_opts[i].name);
1023
1024 /* When instrumenting the pointers, we don't want to remove
1025 the null pointer checks. */
1026 if (opts->x_flag_sanitize & (SANITIZE_NULL | SANITIZE_NONNULL_ATTRIBUTE
1027 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE))
1028 opts->x_flag_delete_null_pointer_checks = 0;
1029
1030 /* Aggressive compiler optimizations may cause false negatives. */
1031 if (opts->x_flag_sanitize & ~(SANITIZE_LEAK | SANITIZE_UNREACHABLE))
1032 opts->x_flag_aggressive_loop_optimizations = 0;
1033
1034 /* Enable -fsanitize-address-use-after-scope if address sanitizer is
1035 enabled. */
1036 if ((opts->x_flag_sanitize & SANITIZE_USER_ADDRESS)
1037 && !opts_set->x_flag_sanitize_address_use_after_scope)
1038 opts->x_flag_sanitize_address_use_after_scope = true;
1039
1040 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1041 is enabled. */
1042 if (opts->x_flag_sanitize_address_use_after_scope)
1043 {
1044 if (opts->x_flag_stack_reuse != SR_NONE
1045 && opts_set->x_flag_stack_reuse != SR_NONE)
1046 error_at (loc,
1047 "%<-fsanitize-address-use-after-scope%> requires "
1048 "%<-fstack-reuse=none%> option");
1049
1050 opts->x_flag_stack_reuse = SR_NONE;
1051 }
1052
1053 if ((opts->x_flag_sanitize & SANITIZE_USER_ADDRESS) && opts->x_flag_tm)
1054 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1055
1056 if ((opts->x_flag_sanitize & SANITIZE_KERNEL_ADDRESS) && opts->x_flag_tm)
1057 sorry ("transactional memory is not supported with "
1058 "%<-fsanitize=kernel-address%>");
1059
1060 /* Comes from final.c -- no real reason to change it. */
1061 #define MAX_CODE_ALIGN 16
1062 #define MAX_CODE_ALIGN_VALUE (1 << MAX_CODE_ALIGN)
1063
1064 if (opts->x_align_loops > MAX_CODE_ALIGN_VALUE)
1065 error_at (loc, "-falign-loops=%d is not between 0 and %d",
1066 opts->x_align_loops, MAX_CODE_ALIGN_VALUE);
1067
1068 if (opts->x_align_jumps > MAX_CODE_ALIGN_VALUE)
1069 error_at (loc, "-falign-jumps=%d is not between 0 and %d",
1070 opts->x_align_jumps, MAX_CODE_ALIGN_VALUE);
1071
1072 if (opts->x_align_functions > MAX_CODE_ALIGN_VALUE)
1073 error_at (loc, "-falign-functions=%d is not between 0 and %d",
1074 opts->x_align_functions, MAX_CODE_ALIGN_VALUE);
1075
1076 if (opts->x_align_labels > MAX_CODE_ALIGN_VALUE)
1077 error_at (loc, "-falign-labels=%d is not between 0 and %d",
1078 opts->x_align_labels, MAX_CODE_ALIGN_VALUE);
1079 }
1080
1081 #define LEFT_COLUMN 27
1082
1083 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1084 followed by word-wrapped HELP in a second column. */
1085 static void
1086 wrap_help (const char *help,
1087 const char *item,
1088 unsigned int item_width,
1089 unsigned int columns)
1090 {
1091 unsigned int col_width = LEFT_COLUMN;
1092 unsigned int remaining, room, len;
1093
1094 remaining = strlen (help);
1095
1096 do
1097 {
1098 room = columns - 3 - MAX (col_width, item_width);
1099 if (room > columns)
1100 room = 0;
1101 len = remaining;
1102
1103 if (room < len)
1104 {
1105 unsigned int i;
1106
1107 for (i = 0; help[i]; i++)
1108 {
1109 if (i >= room && len != remaining)
1110 break;
1111 if (help[i] == ' ')
1112 len = i;
1113 else if ((help[i] == '-' || help[i] == '/')
1114 && help[i + 1] != ' '
1115 && i > 0 && ISALPHA (help[i - 1]))
1116 len = i + 1;
1117 }
1118 }
1119
1120 printf (" %-*.*s %.*s\n", col_width, item_width, item, len, help);
1121 item_width = 0;
1122 while (help[len] == ' ')
1123 len++;
1124 help += len;
1125 remaining -= len;
1126 }
1127 while (remaining);
1128 }
1129
1130 /* Print help for a specific front-end, etc. */
1131 static void
1132 print_filtered_help (unsigned int include_flags,
1133 unsigned int exclude_flags,
1134 unsigned int any_flags,
1135 unsigned int columns,
1136 struct gcc_options *opts,
1137 unsigned int lang_mask)
1138 {
1139 unsigned int i;
1140 const char *help;
1141 bool found = false;
1142 bool displayed = false;
1143 char new_help[256];
1144
1145 if (include_flags == CL_PARAMS)
1146 {
1147 for (i = 0; i < LAST_PARAM; i++)
1148 {
1149 const char *param = compiler_params[i].option;
1150
1151 help = compiler_params[i].help;
1152 if (help == NULL || *help == '\0')
1153 {
1154 if (exclude_flags & CL_UNDOCUMENTED)
1155 continue;
1156 help = undocumented_msg;
1157 }
1158
1159 /* Get the translation. */
1160 help = _(help);
1161
1162 if (!opts->x_quiet_flag)
1163 {
1164 snprintf (new_help, sizeof (new_help),
1165 _("default %d minimum %d maximum %d"),
1166 compiler_params[i].default_value,
1167 compiler_params[i].min_value,
1168 compiler_params[i].max_value);
1169 help = new_help;
1170 }
1171 wrap_help (help, param, strlen (param), columns);
1172 }
1173 putchar ('\n');
1174 return;
1175 }
1176
1177 if (!opts->x_help_printed)
1178 opts->x_help_printed = XCNEWVAR (char, cl_options_count);
1179
1180 if (!opts->x_help_enum_printed)
1181 opts->x_help_enum_printed = XCNEWVAR (char, cl_enums_count);
1182
1183 for (i = 0; i < cl_options_count; i++)
1184 {
1185 const struct cl_option *option = cl_options + i;
1186 unsigned int len;
1187 const char *opt;
1188 const char *tab;
1189
1190 if (include_flags == 0
1191 || ((option->flags & include_flags) != include_flags))
1192 {
1193 if ((option->flags & any_flags) == 0)
1194 continue;
1195 }
1196
1197 /* Skip unwanted switches. */
1198 if ((option->flags & exclude_flags) != 0)
1199 continue;
1200
1201 /* The driver currently prints its own help text. */
1202 if ((option->flags & CL_DRIVER) != 0
1203 && (option->flags & (((1U << cl_lang_count) - 1)
1204 | CL_COMMON | CL_TARGET)) == 0)
1205 continue;
1206
1207 found = true;
1208 /* Skip switches that have already been printed. */
1209 if (opts->x_help_printed[i])
1210 continue;
1211
1212 opts->x_help_printed[i] = true;
1213
1214 help = option->help;
1215 if (help == NULL)
1216 {
1217 if (exclude_flags & CL_UNDOCUMENTED)
1218 continue;
1219
1220 help = undocumented_msg;
1221 }
1222
1223 if (option->alias_target < N_OPTS
1224 && cl_options [option->alias_target].help)
1225 {
1226 if (help == undocumented_msg)
1227 {
1228 /* For undocumented options that are aliases for other options
1229 that are documented, point the reader to the other option in
1230 preference of the former. */
1231 snprintf (new_help, sizeof new_help,
1232 _("Same as %s. Use the latter option instead."),
1233 cl_options [option->alias_target].opt_text);
1234 }
1235 else
1236 {
1237 /* For documented options with aliases, mention the aliased
1238 option's name for reference. */
1239 snprintf (new_help, sizeof new_help,
1240 _("%s Same as %s."),
1241 help, cl_options [option->alias_target].opt_text);
1242 }
1243
1244 help = new_help;
1245 }
1246
1247 if (option->warn_message)
1248 {
1249 /* Mention that the use of the option will trigger a warning. */
1250 if (help == new_help)
1251 snprintf (new_help + strlen (new_help),
1252 sizeof new_help - strlen (new_help),
1253 " %s", _(use_diagnosed_msg));
1254 else
1255 snprintf (new_help, sizeof new_help,
1256 "%s %s", help, _(use_diagnosed_msg));
1257
1258 help = new_help;
1259 }
1260
1261 /* Get the translation. */
1262 help = _(help);
1263
1264 /* Find the gap between the name of the
1265 option and its descriptive text. */
1266 tab = strchr (help, '\t');
1267 if (tab)
1268 {
1269 len = tab - help;
1270 opt = help;
1271 help = tab + 1;
1272 }
1273 else
1274 {
1275 opt = option->opt_text;
1276 len = strlen (opt);
1277 }
1278
1279 /* With the -Q option enabled we change the descriptive text associated
1280 with an option to be an indication of its current setting. */
1281 if (!opts->x_quiet_flag)
1282 {
1283 void *flag_var = option_flag_var (i, opts);
1284
1285 if (len < (LEFT_COLUMN + 2))
1286 strcpy (new_help, "\t\t");
1287 else
1288 strcpy (new_help, "\t");
1289
1290 if (flag_var != NULL
1291 && option->var_type != CLVC_DEFER)
1292 {
1293 if (option->flags & CL_JOINED)
1294 {
1295 if (option->var_type == CLVC_STRING)
1296 {
1297 if (* (const char **) flag_var != NULL)
1298 snprintf (new_help + strlen (new_help),
1299 sizeof (new_help) - strlen (new_help),
1300 "%s", * (const char **) flag_var);
1301 }
1302 else if (option->var_type == CLVC_ENUM)
1303 {
1304 const struct cl_enum *e = &cl_enums[option->var_enum];
1305 int value;
1306 const char *arg = NULL;
1307
1308 value = e->get (flag_var);
1309 enum_value_to_arg (e->values, &arg, value, lang_mask);
1310 if (arg == NULL)
1311 arg = _("[default]");
1312 snprintf (new_help + strlen (new_help),
1313 sizeof (new_help) - strlen (new_help),
1314 "%s", arg);
1315 }
1316 else
1317 sprintf (new_help + strlen (new_help),
1318 "%d", * (int *) flag_var);
1319 }
1320 else
1321 strcat (new_help, option_enabled (i, opts)
1322 ? _("[enabled]") : _("[disabled]"));
1323 }
1324
1325 help = new_help;
1326 }
1327
1328 if (option->range_max != -1)
1329 {
1330 char b[128];
1331 snprintf (b, sizeof (b), "<%d,%d>", option->range_min,
1332 option->range_max);
1333 opt = concat (opt, b, NULL);
1334 len += strlen (b);
1335 }
1336
1337 wrap_help (help, opt, len, columns);
1338 displayed = true;
1339
1340 if (option->var_type == CLVC_ENUM
1341 && opts->x_help_enum_printed[option->var_enum] != 2)
1342 opts->x_help_enum_printed[option->var_enum] = 1;
1343 }
1344
1345 if (! found)
1346 {
1347 unsigned int langs = include_flags & CL_LANG_ALL;
1348
1349 if (langs == 0)
1350 printf (_(" No options with the desired characteristics were found\n"));
1351 else
1352 {
1353 unsigned int i;
1354
1355 /* PR 31349: Tell the user how to see all of the
1356 options supported by a specific front end. */
1357 for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1358 if ((1U << i) & langs)
1359 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1360 lang_names[i], lang_names[i]);
1361 }
1362
1363 }
1364 else if (! displayed)
1365 printf (_(" All options with the desired characteristics have already been displayed\n"));
1366
1367 putchar ('\n');
1368
1369 /* Print details of enumerated option arguments, if those
1370 enumerations have help text headings provided. If no help text
1371 is provided, presume that the possible values are listed in the
1372 help text for the relevant options. */
1373 for (i = 0; i < cl_enums_count; i++)
1374 {
1375 unsigned int j, pos;
1376
1377 if (opts->x_help_enum_printed[i] != 1)
1378 continue;
1379 if (cl_enums[i].help == NULL)
1380 continue;
1381 printf (" %s\n ", _(cl_enums[i].help));
1382 pos = 4;
1383 for (j = 0; cl_enums[i].values[j].arg != NULL; j++)
1384 {
1385 unsigned int len = strlen (cl_enums[i].values[j].arg);
1386
1387 if (pos > 4 && pos + 1 + len <= columns)
1388 {
1389 printf (" %s", cl_enums[i].values[j].arg);
1390 pos += 1 + len;
1391 }
1392 else
1393 {
1394 if (pos > 4)
1395 {
1396 printf ("\n ");
1397 pos = 4;
1398 }
1399 printf ("%s", cl_enums[i].values[j].arg);
1400 pos += len;
1401 }
1402 }
1403 printf ("\n\n");
1404 opts->x_help_enum_printed[i] = 2;
1405 }
1406 }
1407
1408 /* Display help for a specified type of option.
1409 The options must have ALL of the INCLUDE_FLAGS set
1410 ANY of the flags in the ANY_FLAGS set
1411 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1412 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1413 static void
1414 print_specific_help (unsigned int include_flags,
1415 unsigned int exclude_flags,
1416 unsigned int any_flags,
1417 struct gcc_options *opts,
1418 unsigned int lang_mask)
1419 {
1420 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1421 const char * description = NULL;
1422 const char * descrip_extra = "";
1423 size_t i;
1424 unsigned int flag;
1425
1426 /* Sanity check: Make sure that we do not have more
1427 languages than we have bits available to enumerate them. */
1428 gcc_assert ((1U << cl_lang_count) <= CL_MIN_OPTION_CLASS);
1429
1430 /* If we have not done so already, obtain
1431 the desired maximum width of the output. */
1432 if (opts->x_help_columns == 0)
1433 {
1434 opts->x_help_columns = get_terminal_width ();
1435 if (opts->x_help_columns == INT_MAX)
1436 /* Use a reasonable default. */
1437 opts->x_help_columns = 80;
1438 }
1439
1440 /* Decide upon the title for the options that we are going to display. */
1441 for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1442 {
1443 switch (flag & include_flags)
1444 {
1445 case 0:
1446 case CL_DRIVER:
1447 break;
1448
1449 case CL_TARGET:
1450 description = _("The following options are target specific");
1451 break;
1452 case CL_WARNING:
1453 description = _("The following options control compiler warning messages");
1454 break;
1455 case CL_OPTIMIZATION:
1456 description = _("The following options control optimizations");
1457 break;
1458 case CL_COMMON:
1459 description = _("The following options are language-independent");
1460 break;
1461 case CL_PARAMS:
1462 description = _("The --param option recognizes the following as parameters");
1463 break;
1464 default:
1465 if (i >= cl_lang_count)
1466 break;
1467 if (exclude_flags & all_langs_mask)
1468 description = _("The following options are specific to just the language ");
1469 else
1470 description = _("The following options are supported by the language ");
1471 descrip_extra = lang_names [i];
1472 break;
1473 }
1474 }
1475
1476 if (description == NULL)
1477 {
1478 if (any_flags == 0)
1479 {
1480 if (include_flags & CL_UNDOCUMENTED)
1481 description = _("The following options are not documented");
1482 else if (include_flags & CL_SEPARATE)
1483 description = _("The following options take separate arguments");
1484 else if (include_flags & CL_JOINED)
1485 description = _("The following options take joined arguments");
1486 else
1487 {
1488 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1489 include_flags);
1490 return;
1491 }
1492 }
1493 else
1494 {
1495 if (any_flags & all_langs_mask)
1496 description = _("The following options are language-related");
1497 else
1498 description = _("The following options are language-independent");
1499 }
1500 }
1501
1502 printf ("%s%s:\n", description, descrip_extra);
1503 print_filtered_help (include_flags, exclude_flags, any_flags,
1504 opts->x_help_columns, opts, lang_mask);
1505 }
1506
1507 /* Enable FDO-related flags. */
1508
1509 static void
1510 enable_fdo_optimizations (struct gcc_options *opts,
1511 struct gcc_options *opts_set,
1512 int value)
1513 {
1514 if (!opts_set->x_flag_branch_probabilities)
1515 opts->x_flag_branch_probabilities = value;
1516 if (!opts_set->x_flag_profile_values)
1517 opts->x_flag_profile_values = value;
1518 if (!opts_set->x_flag_unroll_loops)
1519 opts->x_flag_unroll_loops = value;
1520 if (!opts_set->x_flag_peel_loops)
1521 opts->x_flag_peel_loops = value;
1522 if (!opts_set->x_flag_tracer)
1523 opts->x_flag_tracer = value;
1524 if (!opts_set->x_flag_value_profile_transformations)
1525 opts->x_flag_value_profile_transformations = value;
1526 if (!opts_set->x_flag_inline_functions)
1527 opts->x_flag_inline_functions = value;
1528 if (!opts_set->x_flag_ipa_cp)
1529 opts->x_flag_ipa_cp = value;
1530 if (!opts_set->x_flag_ipa_cp_clone
1531 && value && opts->x_flag_ipa_cp)
1532 opts->x_flag_ipa_cp_clone = value;
1533 if (!opts_set->x_flag_ipa_bit_cp
1534 && value && opts->x_flag_ipa_cp)
1535 opts->x_flag_ipa_bit_cp = value;
1536 if (!opts_set->x_flag_predictive_commoning)
1537 opts->x_flag_predictive_commoning = value;
1538 if (!opts_set->x_flag_split_loops)
1539 opts->x_flag_split_loops = value;
1540 if (!opts_set->x_flag_unswitch_loops)
1541 opts->x_flag_unswitch_loops = value;
1542 if (!opts_set->x_flag_gcse_after_reload)
1543 opts->x_flag_gcse_after_reload = value;
1544 if (!opts_set->x_flag_tree_loop_vectorize)
1545 opts->x_flag_tree_loop_vectorize = value;
1546 if (!opts_set->x_flag_tree_slp_vectorize)
1547 opts->x_flag_tree_slp_vectorize = value;
1548 if (!opts_set->x_flag_vect_cost_model)
1549 opts->x_flag_vect_cost_model = VECT_COST_MODEL_DYNAMIC;
1550 if (!opts_set->x_flag_tree_loop_distribute_patterns)
1551 opts->x_flag_tree_loop_distribute_patterns = value;
1552 }
1553
1554 /* -f{,no-}sanitize{,-recover}= suboptions. */
1555 const struct sanitizer_opts_s sanitizer_opts[] =
1556 {
1557 #define SANITIZER_OPT(name, flags, recover) \
1558 { #name, flags, sizeof #name - 1, recover }
1559 SANITIZER_OPT (address, (SANITIZE_ADDRESS | SANITIZE_USER_ADDRESS), true),
1560 SANITIZER_OPT (kernel-address, (SANITIZE_ADDRESS | SANITIZE_KERNEL_ADDRESS),
1561 true),
1562 SANITIZER_OPT (pointer-compare, SANITIZE_POINTER_COMPARE, true),
1563 SANITIZER_OPT (pointer-subtract, SANITIZE_POINTER_SUBTRACT, true),
1564 SANITIZER_OPT (thread, SANITIZE_THREAD, false),
1565 SANITIZER_OPT (leak, SANITIZE_LEAK, false),
1566 SANITIZER_OPT (shift, SANITIZE_SHIFT, true),
1567 SANITIZER_OPT (shift-base, SANITIZE_SHIFT_BASE, true),
1568 SANITIZER_OPT (shift-exponent, SANITIZE_SHIFT_EXPONENT, true),
1569 SANITIZER_OPT (integer-divide-by-zero, SANITIZE_DIVIDE, true),
1570 SANITIZER_OPT (undefined, SANITIZE_UNDEFINED, true),
1571 SANITIZER_OPT (unreachable, SANITIZE_UNREACHABLE, false),
1572 SANITIZER_OPT (vla-bound, SANITIZE_VLA, true),
1573 SANITIZER_OPT (return, SANITIZE_RETURN, false),
1574 SANITIZER_OPT (null, SANITIZE_NULL, true),
1575 SANITIZER_OPT (signed-integer-overflow, SANITIZE_SI_OVERFLOW, true),
1576 SANITIZER_OPT (bool, SANITIZE_BOOL, true),
1577 SANITIZER_OPT (enum, SANITIZE_ENUM, true),
1578 SANITIZER_OPT (float-divide-by-zero, SANITIZE_FLOAT_DIVIDE, true),
1579 SANITIZER_OPT (float-cast-overflow, SANITIZE_FLOAT_CAST, true),
1580 SANITIZER_OPT (bounds, SANITIZE_BOUNDS, true),
1581 SANITIZER_OPT (bounds-strict, SANITIZE_BOUNDS | SANITIZE_BOUNDS_STRICT, true),
1582 SANITIZER_OPT (alignment, SANITIZE_ALIGNMENT, true),
1583 SANITIZER_OPT (nonnull-attribute, SANITIZE_NONNULL_ATTRIBUTE, true),
1584 SANITIZER_OPT (returns-nonnull-attribute, SANITIZE_RETURNS_NONNULL_ATTRIBUTE,
1585 true),
1586 SANITIZER_OPT (object-size, SANITIZE_OBJECT_SIZE, true),
1587 SANITIZER_OPT (vptr, SANITIZE_VPTR, true),
1588 SANITIZER_OPT (pointer-overflow, SANITIZE_POINTER_OVERFLOW, true),
1589 SANITIZER_OPT (builtin, SANITIZE_BUILTIN, true),
1590 SANITIZER_OPT (all, ~0U, true),
1591 #undef SANITIZER_OPT
1592 { NULL, 0U, 0UL, false }
1593 };
1594
1595 /* -f{,no-}sanitize-coverage= suboptions. */
1596 const struct sanitizer_opts_s coverage_sanitizer_opts[] =
1597 {
1598 #define COVERAGE_SANITIZER_OPT(name, flags) \
1599 { #name, flags, sizeof #name - 1, true }
1600 COVERAGE_SANITIZER_OPT (trace-pc, SANITIZE_COV_TRACE_PC),
1601 COVERAGE_SANITIZER_OPT (trace-cmp, SANITIZE_COV_TRACE_CMP),
1602 #undef COVERAGE_SANITIZER_OPT
1603 { NULL, 0U, 0UL, false }
1604 };
1605
1606 /* A struct for describing a run of chars within a string. */
1607
1608 struct string_fragment
1609 {
1610 string_fragment (const char *start, size_t len)
1611 : m_start (start), m_len (len) {}
1612
1613 const char *m_start;
1614 size_t m_len;
1615 };
1616
1617 /* Specialization of edit_distance_traits for string_fragment,
1618 for use by get_closest_sanitizer_option. */
1619
1620 template <>
1621 struct edit_distance_traits<const string_fragment &>
1622 {
1623 static size_t get_length (const string_fragment &fragment)
1624 {
1625 return fragment.m_len;
1626 }
1627
1628 static const char *get_string (const string_fragment &fragment)
1629 {
1630 return fragment.m_start;
1631 }
1632 };
1633
1634 /* Given ARG, an unrecognized sanitizer option, return the best
1635 matching sanitizer option, or NULL if there isn't one.
1636 OPTS is array of candidate sanitizer options.
1637 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or
1638 OPT_fsanitize_coverage_.
1639 VALUE is non-zero for the regular form of the option, zero
1640 for the "no-" form (e.g. "-fno-sanitize-recover="). */
1641
1642 static const char *
1643 get_closest_sanitizer_option (const string_fragment &arg,
1644 const struct sanitizer_opts_s *opts,
1645 enum opt_code code, int value)
1646 {
1647 best_match <const string_fragment &, const char*> bm (arg);
1648 for (int i = 0; opts[i].name != NULL; ++i)
1649 {
1650 /* -fsanitize=all is not valid, so don't offer it. */
1651 if (code == OPT_fsanitize_
1652 && opts[i].flag == ~0U
1653 && value)
1654 continue;
1655
1656 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
1657 don't offer the non-recoverable options. */
1658 if (code == OPT_fsanitize_recover_
1659 && !opts[i].can_recover
1660 && value)
1661 continue;
1662
1663 bm.consider (opts[i].name);
1664 }
1665 return bm.get_best_meaningful_candidate ();
1666 }
1667
1668 /* Parse comma separated sanitizer suboptions from P for option SCODE,
1669 adjust previous FLAGS and return new ones. If COMPLAIN is false,
1670 don't issue diagnostics. */
1671
1672 unsigned int
1673 parse_sanitizer_options (const char *p, location_t loc, int scode,
1674 unsigned int flags, int value, bool complain)
1675 {
1676 enum opt_code code = (enum opt_code) scode;
1677
1678 const struct sanitizer_opts_s *opts;
1679 if (code == OPT_fsanitize_coverage_)
1680 opts = coverage_sanitizer_opts;
1681 else
1682 opts = sanitizer_opts;
1683
1684 while (*p != 0)
1685 {
1686 size_t len, i;
1687 bool found = false;
1688 const char *comma = strchr (p, ',');
1689
1690 if (comma == NULL)
1691 len = strlen (p);
1692 else
1693 len = comma - p;
1694 if (len == 0)
1695 {
1696 p = comma + 1;
1697 continue;
1698 }
1699
1700 /* Check to see if the string matches an option class name. */
1701 for (i = 0; opts[i].name != NULL; ++i)
1702 if (len == opts[i].len && memcmp (p, opts[i].name, len) == 0)
1703 {
1704 /* Handle both -fsanitize and -fno-sanitize cases. */
1705 if (value && opts[i].flag == ~0U)
1706 {
1707 if (code == OPT_fsanitize_)
1708 {
1709 if (complain)
1710 error_at (loc, "%<-fsanitize=all%> option is not valid");
1711 }
1712 else
1713 flags |= ~(SANITIZE_THREAD | SANITIZE_LEAK
1714 | SANITIZE_UNREACHABLE | SANITIZE_RETURN);
1715 }
1716 else if (value)
1717 {
1718 /* Do not enable -fsanitize-recover=unreachable and
1719 -fsanitize-recover=return if -fsanitize-recover=undefined
1720 is selected. */
1721 if (code == OPT_fsanitize_recover_
1722 && opts[i].flag == SANITIZE_UNDEFINED)
1723 flags |= (SANITIZE_UNDEFINED
1724 & ~(SANITIZE_UNREACHABLE | SANITIZE_RETURN));
1725 else
1726 flags |= opts[i].flag;
1727 }
1728 else
1729 flags &= ~opts[i].flag;
1730 found = true;
1731 break;
1732 }
1733
1734 if (! found && complain)
1735 {
1736 const char *hint
1737 = get_closest_sanitizer_option (string_fragment (p, len),
1738 opts, code, value);
1739
1740 const char *suffix;
1741 if (code == OPT_fsanitize_recover_)
1742 suffix = "-recover";
1743 else if (code == OPT_fsanitize_coverage_)
1744 suffix = "-coverage";
1745 else
1746 suffix = "";
1747
1748 if (hint)
1749 error_at (loc,
1750 "unrecognized argument to -f%ssanitize%s= option: %q.*s;"
1751 " did you mean %qs?",
1752 value ? "" : "no-",
1753 suffix, (int) len, p, hint);
1754 else
1755 error_at (loc,
1756 "unrecognized argument to -f%ssanitize%s= option: %q.*s",
1757 value ? "" : "no-",
1758 suffix, (int) len, p);
1759 }
1760
1761 if (comma == NULL)
1762 break;
1763 p = comma + 1;
1764 }
1765 return flags;
1766 }
1767
1768 /* Parse string values of no_sanitize attribute passed in VALUE.
1769 Values are separated with comma. */
1770
1771 unsigned int
1772 parse_no_sanitize_attribute (char *value)
1773 {
1774 unsigned int flags = 0;
1775 unsigned int i;
1776 char *q = strtok (value, ",");
1777
1778 while (q != NULL)
1779 {
1780 for (i = 0; sanitizer_opts[i].name != NULL; ++i)
1781 if (strcmp (sanitizer_opts[i].name, q) == 0)
1782 {
1783 flags |= sanitizer_opts[i].flag;
1784 if (sanitizer_opts[i].flag == SANITIZE_UNDEFINED)
1785 flags |= SANITIZE_UNDEFINED_NONDEFAULT;
1786 break;
1787 }
1788
1789 if (sanitizer_opts[i].name == NULL)
1790 warning (OPT_Wattributes,
1791 "%<%s%> attribute directive ignored", q);
1792
1793 q = strtok (NULL, ",");
1794 }
1795
1796 return flags;
1797 }
1798
1799 /* Handle target- and language-independent options. Return zero to
1800 generate an "unknown option" message. Only options that need
1801 extra handling need to be listed here; if you simply want
1802 DECODED->value assigned to a variable, it happens automatically. */
1803
1804 bool
1805 common_handle_option (struct gcc_options *opts,
1806 struct gcc_options *opts_set,
1807 const struct cl_decoded_option *decoded,
1808 unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
1809 location_t loc,
1810 const struct cl_option_handlers *handlers,
1811 diagnostic_context *dc,
1812 void (*target_option_override_hook) (void))
1813 {
1814 size_t scode = decoded->opt_index;
1815 const char *arg = decoded->arg;
1816 int value = decoded->value;
1817 enum opt_code code = (enum opt_code) scode;
1818
1819 gcc_assert (decoded->canonical_option_num_elements <= 2);
1820
1821 switch (code)
1822 {
1823 case OPT__param:
1824 handle_param (opts, opts_set, loc, arg);
1825 break;
1826
1827 case OPT__help:
1828 {
1829 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1830 unsigned int undoc_mask;
1831 unsigned int i;
1832
1833 if (lang_mask == CL_DRIVER)
1834 break;
1835
1836 undoc_mask = ((opts->x_verbose_flag | opts->x_extra_warnings)
1837 ? 0
1838 : CL_UNDOCUMENTED);
1839 target_option_override_hook ();
1840 /* First display any single language specific options. */
1841 for (i = 0; i < cl_lang_count; i++)
1842 print_specific_help
1843 (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0, opts,
1844 lang_mask);
1845 /* Next display any multi language specific options. */
1846 print_specific_help (0, undoc_mask, all_langs_mask, opts, lang_mask);
1847 /* Then display any remaining, non-language options. */
1848 for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1849 if (i != CL_DRIVER)
1850 print_specific_help (i, undoc_mask, 0, opts, lang_mask);
1851 opts->x_exit_after_options = true;
1852 break;
1853 }
1854
1855 case OPT__target_help:
1856 if (lang_mask == CL_DRIVER)
1857 break;
1858
1859 target_option_override_hook ();
1860 print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0, opts, lang_mask);
1861 opts->x_exit_after_options = true;
1862 break;
1863
1864 case OPT__help_:
1865 {
1866 const char *a = arg;
1867 unsigned int include_flags = 0;
1868 /* Note - by default we include undocumented options when listing
1869 specific classes. If you only want to see documented options
1870 then add ",^undocumented" to the --help= option. E.g.:
1871
1872 --help=target,^undocumented */
1873 unsigned int exclude_flags = 0;
1874
1875 if (lang_mask == CL_DRIVER)
1876 break;
1877
1878 /* Walk along the argument string, parsing each word in turn.
1879 The format is:
1880 arg = [^]{word}[,{arg}]
1881 word = {optimizers|target|warnings|undocumented|
1882 params|common|<language>} */
1883 while (*a != 0)
1884 {
1885 static const struct
1886 {
1887 const char *string;
1888 unsigned int flag;
1889 }
1890 specifics[] =
1891 {
1892 { "optimizers", CL_OPTIMIZATION },
1893 { "target", CL_TARGET },
1894 { "warnings", CL_WARNING },
1895 { "undocumented", CL_UNDOCUMENTED },
1896 { "params", CL_PARAMS },
1897 { "joined", CL_JOINED },
1898 { "separate", CL_SEPARATE },
1899 { "common", CL_COMMON },
1900 { NULL, 0 }
1901 };
1902 unsigned int *pflags;
1903 const char *comma;
1904 unsigned int lang_flag, specific_flag;
1905 unsigned int len;
1906 unsigned int i;
1907
1908 if (*a == '^')
1909 {
1910 ++a;
1911 if (*a == '\0')
1912 {
1913 error_at (loc, "missing argument to %qs", "--help=^");
1914 break;
1915 }
1916 pflags = &exclude_flags;
1917 }
1918 else
1919 pflags = &include_flags;
1920
1921 comma = strchr (a, ',');
1922 if (comma == NULL)
1923 len = strlen (a);
1924 else
1925 len = comma - a;
1926 if (len == 0)
1927 {
1928 a = comma + 1;
1929 continue;
1930 }
1931
1932 /* Check to see if the string matches an option class name. */
1933 for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1934 if (strncasecmp (a, specifics[i].string, len) == 0)
1935 {
1936 specific_flag = specifics[i].flag;
1937 break;
1938 }
1939
1940 /* Check to see if the string matches a language name.
1941 Note - we rely upon the alpha-sorted nature of the entries in
1942 the lang_names array, specifically that shorter names appear
1943 before their longer variants. (i.e. C before C++). That way
1944 when we are attempting to match --help=c for example we will
1945 match with C first and not C++. */
1946 for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1947 if (strncasecmp (a, lang_names[i], len) == 0)
1948 {
1949 lang_flag = 1U << i;
1950 break;
1951 }
1952
1953 if (specific_flag != 0)
1954 {
1955 if (lang_flag == 0)
1956 *pflags |= specific_flag;
1957 else
1958 {
1959 /* The option's argument matches both the start of a
1960 language name and the start of an option class name.
1961 We have a special case for when the user has
1962 specified "--help=c", but otherwise we have to issue
1963 a warning. */
1964 if (strncasecmp (a, "c", len) == 0)
1965 *pflags |= lang_flag;
1966 else
1967 warning_at (loc, 0,
1968 "--help argument %q.*s is ambiguous, "
1969 "please be more specific",
1970 len, a);
1971 }
1972 }
1973 else if (lang_flag != 0)
1974 *pflags |= lang_flag;
1975 else
1976 warning_at (loc, 0,
1977 "unrecognized argument to --help= option: %q.*s",
1978 len, a);
1979
1980 if (comma == NULL)
1981 break;
1982 a = comma + 1;
1983 }
1984
1985 if (include_flags)
1986 {
1987 target_option_override_hook ();
1988 print_specific_help (include_flags, exclude_flags, 0, opts,
1989 lang_mask);
1990 }
1991 opts->x_exit_after_options = true;
1992 break;
1993 }
1994
1995 case OPT__version:
1996 if (lang_mask == CL_DRIVER)
1997 break;
1998
1999 opts->x_exit_after_options = true;
2000 break;
2001
2002 case OPT_fsanitize_:
2003 opts->x_flag_sanitize
2004 = parse_sanitizer_options (arg, loc, code,
2005 opts->x_flag_sanitize, value, true);
2006
2007 /* Kernel ASan implies normal ASan but does not yet support
2008 all features. */
2009 if (opts->x_flag_sanitize & SANITIZE_KERNEL_ADDRESS)
2010 {
2011 maybe_set_param_value (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD,
2012 0, opts->x_param_values,
2013 opts_set->x_param_values);
2014 maybe_set_param_value (PARAM_ASAN_GLOBALS, 0, opts->x_param_values,
2015 opts_set->x_param_values);
2016 maybe_set_param_value (PARAM_ASAN_STACK, 0, opts->x_param_values,
2017 opts_set->x_param_values);
2018 maybe_set_param_value (PARAM_ASAN_PROTECT_ALLOCAS, 0,
2019 opts->x_param_values,
2020 opts_set->x_param_values);
2021 maybe_set_param_value (PARAM_ASAN_USE_AFTER_RETURN, 0,
2022 opts->x_param_values,
2023 opts_set->x_param_values);
2024 }
2025 break;
2026
2027 case OPT_fsanitize_recover_:
2028 opts->x_flag_sanitize_recover
2029 = parse_sanitizer_options (arg, loc, code,
2030 opts->x_flag_sanitize_recover, value, true);
2031 break;
2032
2033 case OPT_fasan_shadow_offset_:
2034 /* Deferred. */
2035 break;
2036
2037 case OPT_fsanitize_address_use_after_scope:
2038 opts->x_flag_sanitize_address_use_after_scope = value;
2039 break;
2040
2041 case OPT_fsanitize_recover:
2042 if (value)
2043 opts->x_flag_sanitize_recover
2044 |= (SANITIZE_UNDEFINED | SANITIZE_UNDEFINED_NONDEFAULT)
2045 & ~(SANITIZE_UNREACHABLE | SANITIZE_RETURN);
2046 else
2047 opts->x_flag_sanitize_recover
2048 &= ~(SANITIZE_UNDEFINED | SANITIZE_UNDEFINED_NONDEFAULT);
2049 break;
2050
2051 case OPT_fsanitize_coverage_:
2052 opts->x_flag_sanitize_coverage
2053 = parse_sanitizer_options (arg, loc, code,
2054 opts->x_flag_sanitize_coverage, value, true);
2055 break;
2056
2057 case OPT_O:
2058 case OPT_Os:
2059 case OPT_Ofast:
2060 case OPT_Og:
2061 /* Currently handled in a prescan. */
2062 break;
2063
2064 case OPT_Werror:
2065 dc->warning_as_error_requested = value;
2066 break;
2067
2068 case OPT_Werror_:
2069 if (lang_mask == CL_DRIVER)
2070 break;
2071
2072 enable_warning_as_error (arg, value, lang_mask, handlers,
2073 opts, opts_set, loc, dc);
2074 break;
2075
2076 case OPT_Wlarger_than_:
2077 opts->x_larger_than_size = value;
2078 opts->x_warn_larger_than = value != -1;
2079 break;
2080
2081 case OPT_Wfatal_errors:
2082 dc->fatal_errors = value;
2083 break;
2084
2085 case OPT_Wframe_larger_than_:
2086 opts->x_frame_larger_than_size = value;
2087 opts->x_warn_frame_larger_than = value != -1;
2088 break;
2089
2090 case OPT_Wstack_usage_:
2091 opts->x_warn_stack_usage = value;
2092 opts->x_flag_stack_usage_info = value != -1;
2093 break;
2094
2095 case OPT_Wstrict_aliasing:
2096 set_Wstrict_aliasing (opts, value);
2097 break;
2098
2099 case OPT_Wstrict_overflow:
2100 opts->x_warn_strict_overflow = (value
2101 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2102 : 0);
2103 break;
2104
2105 case OPT_Wsystem_headers:
2106 dc->dc_warn_system_headers = value;
2107 break;
2108
2109 case OPT_aux_info:
2110 opts->x_flag_gen_aux_info = 1;
2111 break;
2112
2113 case OPT_auxbase_strip:
2114 {
2115 char *tmp = xstrdup (arg);
2116 strip_off_ending (tmp, strlen (tmp));
2117 if (tmp[0])
2118 opts->x_aux_base_name = tmp;
2119 else
2120 free (tmp);
2121 }
2122 break;
2123
2124 case OPT_d:
2125 decode_d_option (arg, opts, loc, dc);
2126 break;
2127
2128 case OPT_fcall_used_:
2129 case OPT_fcall_saved_:
2130 /* Deferred. */
2131 break;
2132
2133 case OPT_fdbg_cnt_:
2134 /* Deferred. */
2135 break;
2136
2137 case OPT_fdbg_cnt_list:
2138 /* Deferred. */
2139 opts->x_exit_after_options = true;
2140 break;
2141
2142 case OPT_fdebug_prefix_map_:
2143 case OPT_ffile_prefix_map_:
2144 /* Deferred. */
2145 break;
2146
2147 case OPT_fdiagnostics_show_location_:
2148 diagnostic_prefixing_rule (dc) = (diagnostic_prefixing_rule_t) value;
2149 break;
2150
2151 case OPT_fdiagnostics_show_caret:
2152 dc->show_caret = value;
2153 break;
2154
2155 case OPT_fdiagnostics_color_:
2156 diagnostic_color_init (dc, value);
2157 break;
2158
2159 case OPT_fdiagnostics_parseable_fixits:
2160 dc->parseable_fixits_p = value;
2161 break;
2162
2163 case OPT_fdiagnostics_show_option:
2164 dc->show_option_requested = value;
2165 break;
2166
2167 case OPT_fdump_:
2168 /* Deferred. */
2169 break;
2170
2171 case OPT_ffast_math:
2172 set_fast_math_flags (opts, value);
2173 break;
2174
2175 case OPT_funsafe_math_optimizations:
2176 set_unsafe_math_optimizations_flags (opts, value);
2177 break;
2178
2179 case OPT_ffixed_:
2180 /* Deferred. */
2181 break;
2182
2183 case OPT_finline_limit_:
2184 set_param_value ("max-inline-insns-single", value / 2,
2185 opts->x_param_values, opts_set->x_param_values);
2186 set_param_value ("max-inline-insns-auto", value / 2,
2187 opts->x_param_values, opts_set->x_param_values);
2188 break;
2189
2190 case OPT_finstrument_functions_exclude_function_list_:
2191 add_comma_separated_to_vector
2192 (&opts->x_flag_instrument_functions_exclude_functions, arg);
2193 break;
2194
2195 case OPT_finstrument_functions_exclude_file_list_:
2196 add_comma_separated_to_vector
2197 (&opts->x_flag_instrument_functions_exclude_files, arg);
2198 break;
2199
2200 case OPT_fmessage_length_:
2201 pp_set_line_maximum_length (dc->printer, value);
2202 diagnostic_set_caret_max_width (dc, value);
2203 break;
2204
2205 case OPT_fopt_info:
2206 case OPT_fopt_info_:
2207 /* Deferred. */
2208 break;
2209
2210 case OPT_foffload_:
2211 {
2212 const char *p = arg;
2213 opts->x_flag_disable_hsa = true;
2214 while (*p != 0)
2215 {
2216 const char *comma = strchr (p, ',');
2217
2218 if ((strncmp (p, "disable", 7) == 0)
2219 && (p[7] == ',' || p[7] == '\0'))
2220 {
2221 opts->x_flag_disable_hsa = true;
2222 break;
2223 }
2224
2225 if ((strncmp (p, "hsa", 3) == 0)
2226 && (p[3] == ',' || p[3] == '\0'))
2227 {
2228 #ifdef ENABLE_HSA
2229 opts->x_flag_disable_hsa = false;
2230 #else
2231 sorry ("HSA has not been enabled during configuration");
2232 #endif
2233 }
2234 if (!comma)
2235 break;
2236 p = comma + 1;
2237 }
2238 break;
2239 }
2240
2241 #ifndef ACCEL_COMPILER
2242 case OPT_foffload_abi_:
2243 error_at (loc, "%<-foffload-abi%> option can be specified only for "
2244 "offload compiler");
2245 break;
2246 #endif
2247
2248 case OPT_fpack_struct_:
2249 if (value <= 0 || (value & (value - 1)) || value > 16)
2250 error_at (loc,
2251 "structure alignment must be a small power of two, not %d",
2252 value);
2253 else
2254 opts->x_initial_max_fld_align = value;
2255 break;
2256
2257 case OPT_fplugin_:
2258 case OPT_fplugin_arg_:
2259 /* Deferred. */
2260 break;
2261
2262 case OPT_fprofile_use_:
2263 opts->x_profile_data_prefix = xstrdup (arg);
2264 opts->x_flag_profile_use = true;
2265 value = true;
2266 /* No break here - do -fprofile-use processing. */
2267 /* FALLTHRU */
2268 case OPT_fprofile_use:
2269 enable_fdo_optimizations (opts, opts_set, value);
2270 if (!opts_set->x_flag_profile_reorder_functions)
2271 opts->x_flag_profile_reorder_functions = value;
2272 /* Indirect call profiling should do all useful transformations
2273 speculative devirtualization does. */
2274 if (!opts_set->x_flag_devirtualize_speculatively
2275 && opts->x_flag_value_profile_transformations)
2276 opts->x_flag_devirtualize_speculatively = false;
2277 break;
2278
2279 case OPT_fauto_profile_:
2280 opts->x_auto_profile_file = xstrdup (arg);
2281 opts->x_flag_auto_profile = true;
2282 value = true;
2283 /* No break here - do -fauto-profile processing. */
2284 /* FALLTHRU */
2285 case OPT_fauto_profile:
2286 enable_fdo_optimizations (opts, opts_set, value);
2287 if (!opts_set->x_flag_profile_correction)
2288 opts->x_flag_profile_correction = value;
2289 maybe_set_param_value (
2290 PARAM_EARLY_INLINER_MAX_ITERATIONS, 10,
2291 opts->x_param_values, opts_set->x_param_values);
2292 break;
2293
2294 case OPT_fprofile_generate_:
2295 opts->x_profile_data_prefix = xstrdup (arg);
2296 value = true;
2297 /* No break here - do -fprofile-generate processing. */
2298 /* FALLTHRU */
2299 case OPT_fprofile_generate:
2300 if (!opts_set->x_profile_arc_flag)
2301 opts->x_profile_arc_flag = value;
2302 if (!opts_set->x_flag_profile_values)
2303 opts->x_flag_profile_values = value;
2304 if (!opts_set->x_flag_inline_functions)
2305 opts->x_flag_inline_functions = value;
2306 if (!opts_set->x_flag_ipa_bit_cp)
2307 opts->x_flag_ipa_bit_cp = value;
2308 /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
2309 quadratic. Disable the pass until better memory representation
2310 is done. */
2311 if (!opts_set->x_flag_ipa_reference)
2312 opts->x_flag_ipa_reference = false;
2313 break;
2314
2315 case OPT_fpatchable_function_entry_:
2316 {
2317 char *patch_area_arg = xstrdup (arg);
2318 char *comma = strchr (patch_area_arg, ',');
2319 if (comma)
2320 {
2321 *comma = '\0';
2322 function_entry_patch_area_size =
2323 integral_argument (patch_area_arg);
2324 function_entry_patch_area_start =
2325 integral_argument (comma + 1);
2326 }
2327 else
2328 {
2329 function_entry_patch_area_size =
2330 integral_argument (patch_area_arg);
2331 function_entry_patch_area_start = 0;
2332 }
2333 if (function_entry_patch_area_size < 0
2334 || function_entry_patch_area_start < 0
2335 || function_entry_patch_area_size
2336 < function_entry_patch_area_start)
2337 error ("invalid arguments for %<-fpatchable_function_entry%>");
2338 free (patch_area_arg);
2339 }
2340 break;
2341
2342 case OPT_ftree_vectorize:
2343 /* Automatically sets -ftree-loop-vectorize and
2344 -ftree-slp-vectorize. Nothing more to do here. */
2345 break;
2346 case OPT_fshow_column:
2347 dc->show_column = value;
2348 break;
2349
2350 case OPT_frandom_seed:
2351 /* The real switch is -fno-random-seed. */
2352 if (value)
2353 return false;
2354 /* Deferred. */
2355 break;
2356
2357 case OPT_frandom_seed_:
2358 /* Deferred. */
2359 break;
2360
2361 case OPT_fsched_verbose_:
2362 #ifdef INSN_SCHEDULING
2363 /* Handled with Var in common.opt. */
2364 break;
2365 #else
2366 return false;
2367 #endif
2368
2369 case OPT_fsched_stalled_insns_:
2370 opts->x_flag_sched_stalled_insns = value;
2371 if (opts->x_flag_sched_stalled_insns == 0)
2372 opts->x_flag_sched_stalled_insns = -1;
2373 break;
2374
2375 case OPT_fsched_stalled_insns_dep_:
2376 opts->x_flag_sched_stalled_insns_dep = value;
2377 break;
2378
2379 case OPT_fstack_check_:
2380 if (!strcmp (arg, "no"))
2381 opts->x_flag_stack_check = NO_STACK_CHECK;
2382 else if (!strcmp (arg, "generic"))
2383 /* This is the old stack checking method. */
2384 opts->x_flag_stack_check = STACK_CHECK_BUILTIN
2385 ? FULL_BUILTIN_STACK_CHECK
2386 : GENERIC_STACK_CHECK;
2387 else if (!strcmp (arg, "specific"))
2388 /* This is the new stack checking method. */
2389 opts->x_flag_stack_check = STACK_CHECK_BUILTIN
2390 ? FULL_BUILTIN_STACK_CHECK
2391 : STACK_CHECK_STATIC_BUILTIN
2392 ? STATIC_BUILTIN_STACK_CHECK
2393 : GENERIC_STACK_CHECK;
2394 else
2395 warning_at (loc, 0, "unknown stack check parameter %qs", arg);
2396 break;
2397
2398 case OPT_fstack_limit:
2399 /* The real switch is -fno-stack-limit. */
2400 if (value)
2401 return false;
2402 /* Deferred. */
2403 break;
2404
2405 case OPT_fstack_limit_register_:
2406 case OPT_fstack_limit_symbol_:
2407 /* Deferred. */
2408 break;
2409
2410 case OPT_fstack_usage:
2411 opts->x_flag_stack_usage = value;
2412 opts->x_flag_stack_usage_info = value != 0;
2413 break;
2414
2415 case OPT_g:
2416 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg, opts, opts_set,
2417 loc);
2418 break;
2419
2420 case OPT_gdwarf:
2421 if (arg && strlen (arg) != 0)
2422 {
2423 error_at (loc, "%<-gdwarf%s%> is ambiguous; "
2424 "use %<-gdwarf-%s%> for DWARF version "
2425 "or %<-gdwarf -g%s%> for debug level", arg, arg, arg);
2426 break;
2427 }
2428 else
2429 value = opts->x_dwarf_version;
2430
2431 /* FALLTHRU */
2432 case OPT_gdwarf_:
2433 if (value < 2 || value > 5)
2434 error_at (loc, "dwarf version %d is not supported", value);
2435 else
2436 opts->x_dwarf_version = value;
2437 set_debug_level (DWARF2_DEBUG, false, "", opts, opts_set, loc);
2438 break;
2439
2440 case OPT_gsplit_dwarf:
2441 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, "", opts, opts_set,
2442 loc);
2443 break;
2444
2445 case OPT_ggdb:
2446 set_debug_level (NO_DEBUG, 2, arg, opts, opts_set, loc);
2447 break;
2448
2449 case OPT_gstabs:
2450 case OPT_gstabs_:
2451 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg, opts, opts_set,
2452 loc);
2453 break;
2454
2455 case OPT_gvms:
2456 set_debug_level (VMS_DEBUG, false, arg, opts, opts_set, loc);
2457 break;
2458
2459 case OPT_gxcoff:
2460 case OPT_gxcoff_:
2461 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg, opts, opts_set,
2462 loc);
2463 break;
2464
2465 case OPT_gz:
2466 case OPT_gz_:
2467 /* Handled completely via specs. */
2468 break;
2469
2470 case OPT_pedantic_errors:
2471 dc->pedantic_errors = 1;
2472 control_warning_option (OPT_Wpedantic, DK_ERROR, NULL, value,
2473 loc, lang_mask,
2474 handlers, opts, opts_set,
2475 dc);
2476 break;
2477
2478 case OPT_flto:
2479 opts->x_flag_lto = value ? "" : NULL;
2480 break;
2481
2482 case OPT_w:
2483 dc->dc_inhibit_warnings = true;
2484 break;
2485
2486 case OPT_fmax_errors_:
2487 dc->max_errors = value;
2488 break;
2489
2490 case OPT_fuse_ld_bfd:
2491 case OPT_fuse_ld_gold:
2492 case OPT_fuse_linker_plugin:
2493 /* No-op. Used by the driver and passed to us because it starts with f.*/
2494 break;
2495
2496 case OPT_fwrapv:
2497 if (value)
2498 opts->x_flag_trapv = 0;
2499 break;
2500
2501 case OPT_ftrapv:
2502 if (value)
2503 opts->x_flag_wrapv = 0;
2504 break;
2505
2506 case OPT_fstrict_overflow:
2507 opts->x_flag_wrapv = !value;
2508 opts->x_flag_wrapv_pointer = !value;
2509 if (!value)
2510 opts->x_flag_trapv = 0;
2511 break;
2512
2513 case OPT_fipa_icf:
2514 opts->x_flag_ipa_icf_functions = value;
2515 opts->x_flag_ipa_icf_variables = value;
2516 break;
2517
2518 default:
2519 /* If the flag was handled in a standard way, assume the lack of
2520 processing here is intentional. */
2521 gcc_assert (option_flag_var (scode, opts));
2522 break;
2523 }
2524
2525 common_handle_option_auto (opts, opts_set, decoded, lang_mask, kind,
2526 loc, handlers, dc);
2527 return true;
2528 }
2529
2530 /* Handle --param NAME=VALUE. */
2531 static void
2532 handle_param (struct gcc_options *opts, struct gcc_options *opts_set,
2533 location_t loc, const char *carg)
2534 {
2535 char *equal, *arg;
2536 int value;
2537
2538 arg = xstrdup (carg);
2539 equal = strchr (arg, '=');
2540 if (!equal)
2541 error_at (loc, "%s: --param arguments should be of the form NAME=VALUE",
2542 arg);
2543 else
2544 {
2545 *equal = '\0';
2546
2547 enum compiler_param index;
2548 if (!find_param (arg, &index))
2549 {
2550 const char *suggestion = find_param_fuzzy (arg);
2551 if (suggestion)
2552 error_at (loc, "invalid --param name %qs; did you mean %qs?",
2553 arg, suggestion);
2554 else
2555 error_at (loc, "invalid --param name %qs", arg);
2556 }
2557 else
2558 {
2559 if (!param_string_value_p (index, equal + 1, &value))
2560 value = integral_argument (equal + 1);
2561
2562 if (value == -1)
2563 error_at (loc, "invalid --param value %qs", equal + 1);
2564 else
2565 set_param_value (arg, value,
2566 opts->x_param_values, opts_set->x_param_values);
2567 }
2568 }
2569
2570 free (arg);
2571 }
2572
2573 /* Used to set the level of strict aliasing warnings in OPTS,
2574 when no level is specified (i.e., when -Wstrict-aliasing, and not
2575 -Wstrict-aliasing=level was given).
2576 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2577 and 0 otherwise. After calling this function, wstrict_aliasing will be
2578 set to the default value of -Wstrict_aliasing=level, currently 3. */
2579 static void
2580 set_Wstrict_aliasing (struct gcc_options *opts, int onoff)
2581 {
2582 gcc_assert (onoff == 0 || onoff == 1);
2583 if (onoff != 0)
2584 opts->x_warn_strict_aliasing = 3;
2585 else
2586 opts->x_warn_strict_aliasing = 0;
2587 }
2588
2589 /* The following routines are useful in setting all the flags that
2590 -ffast-math and -fno-fast-math imply. */
2591 static void
2592 set_fast_math_flags (struct gcc_options *opts, int set)
2593 {
2594 if (!opts->frontend_set_flag_unsafe_math_optimizations)
2595 {
2596 opts->x_flag_unsafe_math_optimizations = set;
2597 set_unsafe_math_optimizations_flags (opts, set);
2598 }
2599 if (!opts->frontend_set_flag_finite_math_only)
2600 opts->x_flag_finite_math_only = set;
2601 if (!opts->frontend_set_flag_errno_math)
2602 opts->x_flag_errno_math = !set;
2603 if (set)
2604 {
2605 if (opts->frontend_set_flag_excess_precision_cmdline
2606 == EXCESS_PRECISION_DEFAULT)
2607 opts->x_flag_excess_precision_cmdline
2608 = set ? EXCESS_PRECISION_FAST : EXCESS_PRECISION_DEFAULT;
2609 if (!opts->frontend_set_flag_signaling_nans)
2610 opts->x_flag_signaling_nans = 0;
2611 if (!opts->frontend_set_flag_rounding_math)
2612 opts->x_flag_rounding_math = 0;
2613 if (!opts->frontend_set_flag_cx_limited_range)
2614 opts->x_flag_cx_limited_range = 1;
2615 }
2616 }
2617
2618 /* When -funsafe-math-optimizations is set the following
2619 flags are set as well. */
2620 static void
2621 set_unsafe_math_optimizations_flags (struct gcc_options *opts, int set)
2622 {
2623 if (!opts->frontend_set_flag_trapping_math)
2624 opts->x_flag_trapping_math = !set;
2625 if (!opts->frontend_set_flag_signed_zeros)
2626 opts->x_flag_signed_zeros = !set;
2627 if (!opts->frontend_set_flag_associative_math)
2628 opts->x_flag_associative_math = set;
2629 if (!opts->frontend_set_flag_reciprocal_math)
2630 opts->x_flag_reciprocal_math = set;
2631 }
2632
2633 /* Return true iff flags in OPTS are set as if -ffast-math. */
2634 bool
2635 fast_math_flags_set_p (const struct gcc_options *opts)
2636 {
2637 return (!opts->x_flag_trapping_math
2638 && opts->x_flag_unsafe_math_optimizations
2639 && opts->x_flag_finite_math_only
2640 && !opts->x_flag_signed_zeros
2641 && !opts->x_flag_errno_math
2642 && opts->x_flag_excess_precision_cmdline
2643 == EXCESS_PRECISION_FAST);
2644 }
2645
2646 /* Return true iff flags are set as if -ffast-math but using the flags stored
2647 in the struct cl_optimization structure. */
2648 bool
2649 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2650 {
2651 return (!opt->x_flag_trapping_math
2652 && opt->x_flag_unsafe_math_optimizations
2653 && opt->x_flag_finite_math_only
2654 && !opt->x_flag_signed_zeros
2655 && !opt->x_flag_errno_math);
2656 }
2657
2658 /* Handle a debug output -g switch for options OPTS
2659 (OPTS_SET->x_write_symbols storing whether a debug type was passed
2660 explicitly), location LOC. EXTENDED is true or false to support
2661 extended output (2 is special and means "-ggdb" was given). */
2662 static void
2663 set_debug_level (enum debug_info_type type, int extended, const char *arg,
2664 struct gcc_options *opts, struct gcc_options *opts_set,
2665 location_t loc)
2666 {
2667 opts->x_use_gnu_debug_info_extensions = extended;
2668
2669 if (type == NO_DEBUG)
2670 {
2671 if (opts->x_write_symbols == NO_DEBUG)
2672 {
2673 opts->x_write_symbols = PREFERRED_DEBUGGING_TYPE;
2674
2675 if (extended == 2)
2676 {
2677 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
2678 opts->x_write_symbols = DWARF2_DEBUG;
2679 #elif defined DBX_DEBUGGING_INFO
2680 opts->x_write_symbols = DBX_DEBUG;
2681 #endif
2682 }
2683
2684 if (opts->x_write_symbols == NO_DEBUG)
2685 warning_at (loc, 0, "target system does not support debug output");
2686 }
2687 }
2688 else
2689 {
2690 /* Does it conflict with an already selected type? */
2691 if (opts_set->x_write_symbols != NO_DEBUG
2692 && opts->x_write_symbols != NO_DEBUG
2693 && type != opts->x_write_symbols)
2694 error_at (loc, "debug format %qs conflicts with prior selection",
2695 debug_type_names[type]);
2696 opts->x_write_symbols = type;
2697 opts_set->x_write_symbols = type;
2698 }
2699
2700 /* A debug flag without a level defaults to level 2.
2701 If off or at level 1, set it to level 2, but if already
2702 at level 3, don't lower it. */
2703 if (*arg == '\0')
2704 {
2705 if (opts->x_debug_info_level < DINFO_LEVEL_NORMAL)
2706 opts->x_debug_info_level = DINFO_LEVEL_NORMAL;
2707 }
2708 else
2709 {
2710 int argval = integral_argument (arg);
2711 if (argval == -1)
2712 error_at (loc, "unrecognized debug output level %qs", arg);
2713 else if (argval > 3)
2714 error_at (loc, "debug output level %qs is too high", arg);
2715 else
2716 opts->x_debug_info_level = (enum debug_info_levels) argval;
2717 }
2718 }
2719
2720 /* Arrange to dump core on error for diagnostic context DC. (The
2721 regular error message is still printed first, except in the case of
2722 abort ().) */
2723
2724 static void
2725 setup_core_dumping (diagnostic_context *dc)
2726 {
2727 #ifdef SIGABRT
2728 signal (SIGABRT, SIG_DFL);
2729 #endif
2730 #if defined(HAVE_SETRLIMIT)
2731 {
2732 struct rlimit rlim;
2733 if (getrlimit (RLIMIT_CORE, &rlim) != 0)
2734 fatal_error (input_location, "getting core file size maximum limit: %m");
2735 rlim.rlim_cur = rlim.rlim_max;
2736 if (setrlimit (RLIMIT_CORE, &rlim) != 0)
2737 fatal_error (input_location,
2738 "setting core file size limit to maximum: %m");
2739 }
2740 #endif
2741 diagnostic_abort_on_error (dc);
2742 }
2743
2744 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
2745 diagnostic context DC. */
2746
2747 static void
2748 decode_d_option (const char *arg, struct gcc_options *opts,
2749 location_t loc, diagnostic_context *dc)
2750 {
2751 int c;
2752
2753 while (*arg)
2754 switch (c = *arg++)
2755 {
2756 case 'A':
2757 opts->x_flag_debug_asm = 1;
2758 break;
2759 case 'p':
2760 opts->x_flag_print_asm_name = 1;
2761 break;
2762 case 'P':
2763 opts->x_flag_dump_rtl_in_asm = 1;
2764 opts->x_flag_print_asm_name = 1;
2765 break;
2766 case 'x':
2767 opts->x_rtl_dump_and_exit = 1;
2768 break;
2769 case 'D': /* These are handled by the preprocessor. */
2770 case 'I':
2771 case 'M':
2772 case 'N':
2773 case 'U':
2774 break;
2775 case 'H':
2776 setup_core_dumping (dc);
2777 break;
2778 case 'a':
2779 opts->x_flag_dump_all_passed = true;
2780 break;
2781
2782 default:
2783 warning_at (loc, 0, "unrecognized gcc debugging option: %c", c);
2784 break;
2785 }
2786 }
2787
2788 /* Enable (or disable if VALUE is 0) a warning option ARG (language
2789 mask LANG_MASK, option handlers HANDLERS) as an error for option
2790 structures OPTS and OPTS_SET, diagnostic context DC (possibly
2791 NULL), location LOC. This is used by -Werror=. */
2792
2793 static void
2794 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
2795 const struct cl_option_handlers *handlers,
2796 struct gcc_options *opts,
2797 struct gcc_options *opts_set,
2798 location_t loc, diagnostic_context *dc)
2799 {
2800 char *new_option;
2801 int option_index;
2802
2803 new_option = XNEWVEC (char, strlen (arg) + 2);
2804 new_option[0] = 'W';
2805 strcpy (new_option + 1, arg);
2806 option_index = find_opt (new_option, lang_mask);
2807 if (option_index == OPT_SPECIAL_unknown)
2808 error_at (loc, "-Werror=%s: no option -%s", arg, new_option);
2809 else if (!(cl_options[option_index].flags & CL_WARNING))
2810 error_at (loc, "-Werror=%s: -%s is not an option that controls warnings",
2811 arg, new_option);
2812 else
2813 {
2814 const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
2815 const char *arg = NULL;
2816
2817 if (cl_options[option_index].flags & CL_JOINED)
2818 arg = new_option + cl_options[option_index].opt_len;
2819 control_warning_option (option_index, (int) kind, arg, value,
2820 loc, lang_mask,
2821 handlers, opts, opts_set, dc);
2822 }
2823 free (new_option);
2824 }
2825
2826 /* Return malloced memory for the name of the option OPTION_INDEX
2827 which enabled a diagnostic (context CONTEXT), originally of type
2828 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2829 as -Werror. */
2830
2831 char *
2832 option_name (diagnostic_context *context, int option_index,
2833 diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
2834 {
2835 if (option_index)
2836 {
2837 /* A warning classified as an error. */
2838 if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
2839 && diag_kind == DK_ERROR)
2840 return concat (cl_options[OPT_Werror_].opt_text,
2841 /* Skip over "-W". */
2842 cl_options[option_index].opt_text + 2,
2843 NULL);
2844 /* A warning with option. */
2845 else
2846 return xstrdup (cl_options[option_index].opt_text);
2847 }
2848 /* A warning without option classified as an error. */
2849 else if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
2850 || diag_kind == DK_WARNING)
2851 && context->warning_as_error_requested)
2852 return xstrdup (cl_options[OPT_Werror].opt_text);
2853 else
2854 return NULL;
2855 }
DragonFly BSD