?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
aix: Support libsupc++ as a FAT library
[official-gcc.git] / gcc / opts.c
blobc5c60581f70220a89289a59e5f4a6b1a282fd8b9
1 /* Command line option handling.
2 Copyright (C) 2002-2020 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 "diagnostic.h"
29 #include "opts-diagnostic.h"
30 #include "insn-attr-common.h"
31 #include "common/common-target.h"
32 #include "spellcheck.h"
33 #include "opt-suggestions.h"
34 #include "diagnostic-color.h"
35 #include "selftest.h"
36
37 static void set_Wstrict_aliasing (struct gcc_options *opts, int onoff);
38
39 /* Indexed by enum debug_info_type. */
40 const char *const debug_type_names[] =
41 {
42 "none", "stabs", "dwarf-2", "xcoff", "vms"
43 };
44
45 /* Parse the -femit-struct-debug-detailed option value
46 and set the flag variables. */
47
48 #define MATCH( prefix, string ) \
49 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
50 ? ((string += sizeof prefix - 1), 1) : 0)
51
52 void
53 set_struct_debug_option (struct gcc_options *opts, location_t loc,
54 const char *spec)
55 {
56 /* various labels for comparison */
57 static const char dfn_lbl[] = "dfn:", dir_lbl[] = "dir:", ind_lbl[] = "ind:";
58 static const char ord_lbl[] = "ord:", gen_lbl[] = "gen:";
59 static const char none_lbl[] = "none", any_lbl[] = "any";
60 static const char base_lbl[] = "base", sys_lbl[] = "sys";
61
62 enum debug_struct_file files = DINFO_STRUCT_FILE_ANY;
63 /* Default is to apply to as much as possible. */
64 enum debug_info_usage usage = DINFO_USAGE_NUM_ENUMS;
65 int ord = 1, gen = 1;
66
67 /* What usage? */
68 if (MATCH (dfn_lbl, spec))
69 usage = DINFO_USAGE_DFN;
70 else if (MATCH (dir_lbl, spec))
71 usage = DINFO_USAGE_DIR_USE;
72 else if (MATCH (ind_lbl, spec))
73 usage = DINFO_USAGE_IND_USE;
74
75 /* Generics or not? */
76 if (MATCH (ord_lbl, spec))
77 gen = 0;
78 else if (MATCH (gen_lbl, spec))
79 ord = 0;
80
81 /* What allowable environment? */
82 if (MATCH (none_lbl, spec))
83 files = DINFO_STRUCT_FILE_NONE;
84 else if (MATCH (any_lbl, spec))
85 files = DINFO_STRUCT_FILE_ANY;
86 else if (MATCH (sys_lbl, spec))
87 files = DINFO_STRUCT_FILE_SYS;
88 else if (MATCH (base_lbl, spec))
89 files = DINFO_STRUCT_FILE_BASE;
90 else
91 error_at (loc,
92 "argument %qs to %<-femit-struct-debug-detailed%> "
93 "not recognized",
94 spec);
95
96 /* Effect the specification. */
97 if (usage == DINFO_USAGE_NUM_ENUMS)
98 {
99 if (ord)
100 {
101 opts->x_debug_struct_ordinary[DINFO_USAGE_DFN] = files;
102 opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE] = files;
103 opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE] = files;
104 }
105 if (gen)
106 {
107 opts->x_debug_struct_generic[DINFO_USAGE_DFN] = files;
108 opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE] = files;
109 opts->x_debug_struct_generic[DINFO_USAGE_IND_USE] = files;
110 }
111 }
112 else
113 {
114 if (ord)
115 opts->x_debug_struct_ordinary[usage] = files;
116 if (gen)
117 opts->x_debug_struct_generic[usage] = files;
118 }
119
120 if (*spec == ',')
121 set_struct_debug_option (opts, loc, spec+1);
122 else
123 {
124 /* No more -femit-struct-debug-detailed specifications.
125 Do final checks. */
126 if (*spec != '\0')
127 error_at (loc,
128 "argument %qs to %<-femit-struct-debug-detailed%> unknown",
129 spec);
130 if (opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE]
131 < opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE]
132 || opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE]
133 < opts->x_debug_struct_generic[DINFO_USAGE_IND_USE])
134 error_at (loc,
135 "%<-femit-struct-debug-detailed=dir:...%> must allow "
136 "at least as much as "
137 "%<-femit-struct-debug-detailed=ind:...%>");
138 }
139 }
140
141 /* Strip off a legitimate source ending from the input string NAME of
142 length LEN. Rather than having to know the names used by all of
143 our front ends, we strip off an ending of a period followed by
144 up to fource characters. (C++ uses ".cpp".) */
145
146 void
147 strip_off_ending (char *name, int len)
148 {
149 int i;
150 for (i = 2; i < 5 && len > i; i++)
151 {
152 if (name[len - i] == '.')
153 {
154 name[len - i] = '\0';
155 break;
156 }
157 }
158 }
159
160 /* Find the base name of a path, stripping off both directories and
161 a single final extension. */
162 int
163 base_of_path (const char *path, const char **base_out)
164 {
165 const char *base = path;
166 const char *dot = 0;
167 const char *p = path;
168 char c = *p;
169 while (c)
170 {
171 if (IS_DIR_SEPARATOR (c))
172 {
173 base = p + 1;
174 dot = 0;
175 }
176 else if (c == '.')
177 dot = p;
178 c = *++p;
179 }
180 if (!dot)
181 dot = p;
182 *base_out = base;
183 return dot - base;
184 }
185
186 /* What to print when a switch has no documentation. */
187 static const char undocumented_msg[] = N_("This option lacks documentation.");
188 static const char use_diagnosed_msg[] = N_("Uses of this option are diagnosed.");
189
190 typedef char *char_p; /* For DEF_VEC_P. */
191
192 static void set_debug_level (enum debug_info_type type, int extended,
193 const char *arg, struct gcc_options *opts,
194 struct gcc_options *opts_set,
195 location_t loc);
196 static void set_fast_math_flags (struct gcc_options *opts, int set);
197 static void decode_d_option (const char *arg, struct gcc_options *opts,
198 location_t loc, diagnostic_context *dc);
199 static void set_unsafe_math_optimizations_flags (struct gcc_options *opts,
200 int set);
201 static void enable_warning_as_error (const char *arg, int value,
202 unsigned int lang_mask,
203 const struct cl_option_handlers *handlers,
204 struct gcc_options *opts,
205 struct gcc_options *opts_set,
206 location_t loc,
207 diagnostic_context *dc);
208
209 /* Handle a back-end option; arguments and return value as for
210 handle_option. */
211
212 bool
213 target_handle_option (struct gcc_options *opts,
214 struct gcc_options *opts_set,
215 const struct cl_decoded_option *decoded,
216 unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
217 location_t loc,
218 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
219 diagnostic_context *dc, void (*) (void))
220 {
221 gcc_assert (dc == global_dc);
222 gcc_assert (kind == DK_UNSPECIFIED);
223 return targetm_common.handle_option (opts, opts_set, decoded, loc);
224 }
225
226 /* Add comma-separated strings to a char_p vector. */
227
228 static void
229 add_comma_separated_to_vector (void **pvec, const char *arg)
230 {
231 char *tmp;
232 char *r;
233 char *w;
234 char *token_start;
235 vec<char_p> *v = (vec<char_p> *) *pvec;
236
237 vec_check_alloc (v, 1);
238
239 /* We never free this string. */
240 tmp = xstrdup (arg);
241
242 r = tmp;
243 w = tmp;
244 token_start = tmp;
245
246 while (*r != '\0')
247 {
248 if (*r == ',')
249 {
250 *w++ = '\0';
251 ++r;
252 v->safe_push (token_start);
253 token_start = w;
254 }
255 if (*r == '\\' && r[1] == ',')
256 {
257 *w++ = ',';
258 r += 2;
259 }
260 else
261 *w++ = *r++;
262 }
263
264 *w = '\0';
265 if (*token_start != '\0')
266 v->safe_push (token_start);
267
268 *pvec = v;
269 }
270
271 /* Initialize opts_obstack. */
272
273 void
274 init_opts_obstack (void)
275 {
276 gcc_obstack_init (&opts_obstack);
277 }
278
279 /* Initialize OPTS and OPTS_SET before using them in parsing options. */
280
281 void
282 init_options_struct (struct gcc_options *opts, struct gcc_options *opts_set)
283 {
284 /* Ensure that opts_obstack has already been initialized by the time
285 that we initialize any gcc_options instances (PR jit/68446). */
286 gcc_assert (opts_obstack.chunk_size > 0);
287
288 *opts = global_options_init;
289
290 if (opts_set)
291 memset (opts_set, 0, sizeof (*opts_set));
292
293 /* Initialize whether `char' is signed. */
294 opts->x_flag_signed_char = DEFAULT_SIGNED_CHAR;
295 /* Set this to a special "uninitialized" value. The actual default
296 is set after target options have been processed. */
297 opts->x_flag_short_enums = 2;
298
299 /* Initialize target_flags before default_options_optimization
300 so the latter can modify it. */
301 opts->x_target_flags = targetm_common.default_target_flags;
302
303 /* Some targets have ABI-specified unwind tables. */
304 opts->x_flag_unwind_tables = targetm_common.unwind_tables_default;
305
306 /* Some targets have other target-specific initialization. */
307 targetm_common.option_init_struct (opts);
308 }
309
310 /* If indicated by the optimization level LEVEL (-Os if SIZE is set,
311 -Ofast if FAST is set, -Og if DEBUG is set), apply the option DEFAULT_OPT
312 to OPTS and OPTS_SET, diagnostic context DC, location LOC, with language
313 mask LANG_MASK and option handlers HANDLERS. */
314
315 static void
316 maybe_default_option (struct gcc_options *opts,
317 struct gcc_options *opts_set,
318 const struct default_options *default_opt,
319 int level, bool size, bool fast, bool debug,
320 unsigned int lang_mask,
321 const struct cl_option_handlers *handlers,
322 location_t loc,
323 diagnostic_context *dc)
324 {
325 const struct cl_option *option = &cl_options[default_opt->opt_index];
326 bool enabled;
327
328 if (size)
329 gcc_assert (level == 2);
330 if (fast)
331 gcc_assert (level == 3);
332 if (debug)
333 gcc_assert (level == 1);
334
335 switch (default_opt->levels)
336 {
337 case OPT_LEVELS_ALL:
338 enabled = true;
339 break;
340
341 case OPT_LEVELS_0_ONLY:
342 enabled = (level == 0);
343 break;
344
345 case OPT_LEVELS_1_PLUS:
346 enabled = (level >= 1);
347 break;
348
349 case OPT_LEVELS_1_PLUS_SPEED_ONLY:
350 enabled = (level >= 1 && !size && !debug);
351 break;
352
353 case OPT_LEVELS_1_PLUS_NOT_DEBUG:
354 enabled = (level >= 1 && !debug);
355 break;
356
357 case OPT_LEVELS_2_PLUS:
358 enabled = (level >= 2);
359 break;
360
361 case OPT_LEVELS_2_PLUS_SPEED_ONLY:
362 enabled = (level >= 2 && !size && !debug);
363 break;
364
365 case OPT_LEVELS_3_PLUS:
366 enabled = (level >= 3);
367 break;
368
369 case OPT_LEVELS_3_PLUS_AND_SIZE:
370 enabled = (level >= 3 || size);
371 break;
372
373 case OPT_LEVELS_SIZE:
374 enabled = size;
375 break;
376
377 case OPT_LEVELS_FAST:
378 enabled = fast;
379 break;
380
381 case OPT_LEVELS_NONE:
382 default:
383 gcc_unreachable ();
384 }
385
386 if (enabled)
387 handle_generated_option (opts, opts_set, default_opt->opt_index,
388 default_opt->arg, default_opt->value,
389 lang_mask, DK_UNSPECIFIED, loc,
390 handlers, true, dc);
391 else if (default_opt->arg == NULL
392 && !option->cl_reject_negative
393 && !(option->flags & CL_PARAMS))
394 handle_generated_option (opts, opts_set, default_opt->opt_index,
395 default_opt->arg, !default_opt->value,
396 lang_mask, DK_UNSPECIFIED, loc,
397 handlers, true, dc);
398 }
399
400 /* As indicated by the optimization level LEVEL (-Os if SIZE is set,
401 -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
402 OPTS and OPTS_SET, diagnostic context DC, location LOC, with
403 language mask LANG_MASK and option handlers HANDLERS. */
404
405 static void
406 maybe_default_options (struct gcc_options *opts,
407 struct gcc_options *opts_set,
408 const struct default_options *default_opts,
409 int level, bool size, bool fast, bool debug,
410 unsigned int lang_mask,
411 const struct cl_option_handlers *handlers,
412 location_t loc,
413 diagnostic_context *dc)
414 {
415 size_t i;
416
417 for (i = 0; default_opts[i].levels != OPT_LEVELS_NONE; i++)
418 maybe_default_option (opts, opts_set, &default_opts[i],
419 level, size, fast, debug,
420 lang_mask, handlers, loc, dc);
421 }
422
423 /* Table of options enabled by default at different levels.
424 Please keep this list sorted by level and alphabetized within
425 each level; this makes it easier to keep the documentation
426 in sync. */
427
428 static const struct default_options default_options_table[] =
429 {
430 /* -O1 and -Og optimizations. */
431 { OPT_LEVELS_1_PLUS, OPT_fcombine_stack_adjustments, NULL, 1 },
432 { OPT_LEVELS_1_PLUS, OPT_fcompare_elim, NULL, 1 },
433 { OPT_LEVELS_1_PLUS, OPT_fcprop_registers, NULL, 1 },
434 { OPT_LEVELS_1_PLUS, OPT_fdefer_pop, NULL, 1 },
435 { OPT_LEVELS_1_PLUS, OPT_fforward_propagate, NULL, 1 },
436 { OPT_LEVELS_1_PLUS, OPT_fguess_branch_probability, NULL, 1 },
437 { OPT_LEVELS_1_PLUS, OPT_fipa_profile, NULL, 1 },
438 { OPT_LEVELS_1_PLUS, OPT_fipa_pure_const, NULL, 1 },
439 { OPT_LEVELS_1_PLUS, OPT_fipa_reference, NULL, 1 },
440 { OPT_LEVELS_1_PLUS, OPT_fipa_reference_addressable, NULL, 1 },
441 { OPT_LEVELS_1_PLUS, OPT_fmerge_constants, NULL, 1 },
442 { OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
443 { OPT_LEVELS_1_PLUS, OPT_freorder_blocks, NULL, 1 },
444 { OPT_LEVELS_1_PLUS, OPT_fshrink_wrap, NULL, 1 },
445 { OPT_LEVELS_1_PLUS, OPT_fsplit_wide_types, NULL, 1 },
446 { OPT_LEVELS_1_PLUS, OPT_ftree_builtin_call_dce, NULL, 1 },
447 { OPT_LEVELS_1_PLUS, OPT_ftree_ccp, NULL, 1 },
448 { OPT_LEVELS_1_PLUS, OPT_ftree_ch, NULL, 1 },
449 { OPT_LEVELS_1_PLUS, OPT_ftree_coalesce_vars, NULL, 1 },
450 { OPT_LEVELS_1_PLUS, OPT_ftree_copy_prop, NULL, 1 },
451 { OPT_LEVELS_1_PLUS, OPT_ftree_dce, NULL, 1 },
452 { OPT_LEVELS_1_PLUS, OPT_ftree_dominator_opts, NULL, 1 },
453 { OPT_LEVELS_1_PLUS, OPT_ftree_fre, NULL, 1 },
454 { OPT_LEVELS_1_PLUS, OPT_ftree_sink, NULL, 1 },
455 { OPT_LEVELS_1_PLUS, OPT_ftree_slsr, NULL, 1 },
456 { OPT_LEVELS_1_PLUS, OPT_ftree_ter, NULL, 1 },
457
458 /* -O1 (and not -Og) optimizations. */
459 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fbranch_count_reg, NULL, 1 },
460 #if DELAY_SLOTS
461 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fdelayed_branch, NULL, 1 },
462 #endif
463 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fdse, NULL, 1 },
464 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fif_conversion, NULL, 1 },
465 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fif_conversion2, NULL, 1 },
466 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_finline_functions_called_once, NULL, 1 },
467 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fmove_loop_invariants, NULL, 1 },
468 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fssa_phiopt, NULL, 1 },
469 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_bit_ccp, NULL, 1 },
470 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_dse, NULL, 1 },
471 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_pta, NULL, 1 },
472 { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_sra, NULL, 1 },
473
474 /* -O2 and -Os optimizations. */
475 { OPT_LEVELS_2_PLUS, OPT_fcaller_saves, NULL, 1 },
476 { OPT_LEVELS_2_PLUS, OPT_fcode_hoisting, NULL, 1 },
477 { OPT_LEVELS_2_PLUS, OPT_fcrossjumping, NULL, 1 },
478 { OPT_LEVELS_2_PLUS, OPT_fcse_follow_jumps, NULL, 1 },
479 { OPT_LEVELS_2_PLUS, OPT_fdevirtualize, NULL, 1 },
480 { OPT_LEVELS_2_PLUS, OPT_fdevirtualize_speculatively, NULL, 1 },
481 { OPT_LEVELS_2_PLUS, OPT_fexpensive_optimizations, NULL, 1 },
482 { OPT_LEVELS_2_PLUS, OPT_fgcse, NULL, 1 },
483 { OPT_LEVELS_2_PLUS, OPT_fhoist_adjacent_loads, NULL, 1 },
484 { OPT_LEVELS_2_PLUS, OPT_findirect_inlining, NULL, 1 },
485 { OPT_LEVELS_2_PLUS, OPT_finline_small_functions, NULL, 1 },
486 { OPT_LEVELS_2_PLUS, OPT_fipa_bit_cp, NULL, 1 },
487 { OPT_LEVELS_2_PLUS, OPT_fipa_cp, NULL, 1 },
488 { OPT_LEVELS_2_PLUS, OPT_fipa_icf, NULL, 1 },
489 { OPT_LEVELS_2_PLUS, OPT_fipa_ra, NULL, 1 },
490 { OPT_LEVELS_2_PLUS, OPT_fipa_sra, NULL, 1 },
491 { OPT_LEVELS_2_PLUS, OPT_fipa_vrp, NULL, 1 },
492 { OPT_LEVELS_2_PLUS, OPT_fisolate_erroneous_paths_dereference, NULL, 1 },
493 { OPT_LEVELS_2_PLUS, OPT_flra_remat, NULL, 1 },
494 { OPT_LEVELS_2_PLUS, OPT_foptimize_sibling_calls, NULL, 1 },
495 { OPT_LEVELS_2_PLUS, OPT_fpartial_inlining, NULL, 1 },
496 { OPT_LEVELS_2_PLUS, OPT_fpeephole2, NULL, 1 },
497 { OPT_LEVELS_2_PLUS, OPT_freorder_functions, NULL, 1 },
498 { OPT_LEVELS_2_PLUS, OPT_frerun_cse_after_loop, NULL, 1 },
499 #ifdef INSN_SCHEDULING
500 { OPT_LEVELS_2_PLUS, OPT_fschedule_insns2, NULL, 1 },
501 #endif
502 { OPT_LEVELS_2_PLUS, OPT_fstrict_aliasing, NULL, 1 },
503 { OPT_LEVELS_2_PLUS, OPT_fstore_merging, NULL, 1 },
504 { OPT_LEVELS_2_PLUS, OPT_fthread_jumps, 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_ftree_tail_merge, NULL, 1 },
508 { OPT_LEVELS_2_PLUS, OPT_ftree_vrp, NULL, 1 },
509 { OPT_LEVELS_2_PLUS, OPT_fvect_cost_model_, NULL, VECT_COST_MODEL_CHEAP },
510 { OPT_LEVELS_2_PLUS, OPT_finline_functions, NULL, 1 },
511 { OPT_LEVELS_2_PLUS, OPT_ftree_loop_distribute_patterns, NULL, 1 },
512
513 /* -O2 and above optimizations, but not -Os or -Og. */
514 { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_falign_functions, NULL, 1 },
515 { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_falign_jumps, NULL, 1 },
516 { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_falign_labels, NULL, 1 },
517 { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_falign_loops, NULL, 1 },
518 { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_foptimize_strlen, NULL, 1 },
519 { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_freorder_blocks_algorithm_, NULL,
520 REORDER_BLOCKS_ALGORITHM_STC },
521 #ifdef INSN_SCHEDULING
522 /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
523 { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_fschedule_insns, NULL, 1 },
524 #endif
525
526 /* -O3 and -Os optimizations. */
527
528 /* -O3 optimizations. */
529 { OPT_LEVELS_3_PLUS, OPT_fgcse_after_reload, NULL, 1 },
530 { OPT_LEVELS_3_PLUS, OPT_fipa_cp_clone, NULL, 1 },
531 { OPT_LEVELS_3_PLUS, OPT_floop_interchange, NULL, 1 },
532 { OPT_LEVELS_3_PLUS, OPT_floop_unroll_and_jam, NULL, 1 },
533 { OPT_LEVELS_3_PLUS, OPT_fpeel_loops, NULL, 1 },
534 { OPT_LEVELS_3_PLUS, OPT_fpredictive_commoning, NULL, 1 },
535 { OPT_LEVELS_3_PLUS, OPT_fsplit_loops, NULL, 1 },
536 { OPT_LEVELS_3_PLUS, OPT_fsplit_paths, NULL, 1 },
537 { OPT_LEVELS_3_PLUS, OPT_ftree_loop_distribution, NULL, 1 },
538 { OPT_LEVELS_3_PLUS, OPT_ftree_loop_vectorize, NULL, 1 },
539 { OPT_LEVELS_3_PLUS, OPT_ftree_partial_pre, NULL, 1 },
540 { OPT_LEVELS_3_PLUS, OPT_ftree_slp_vectorize, NULL, 1 },
541 { OPT_LEVELS_3_PLUS, OPT_funswitch_loops, NULL, 1 },
542 { OPT_LEVELS_3_PLUS, OPT_fvect_cost_model_, NULL, VECT_COST_MODEL_DYNAMIC },
543 { OPT_LEVELS_3_PLUS, OPT_fversion_loops_for_strides, NULL, 1 },
544
545 /* -O3 parameters. */
546 { OPT_LEVELS_3_PLUS, OPT__param_max_inline_insns_auto_, NULL, 30 },
547 { OPT_LEVELS_3_PLUS, OPT__param_early_inlining_insns_, NULL, 14 },
548 { OPT_LEVELS_3_PLUS, OPT__param_inline_heuristics_hint_percent_, NULL, 600 },
549 { OPT_LEVELS_3_PLUS, OPT__param_inline_min_speedup_, NULL, 15 },
550 { OPT_LEVELS_3_PLUS, OPT__param_max_inline_insns_single_, NULL, 200 },
551
552 /* -Ofast adds optimizations to -O3. */
553 { OPT_LEVELS_FAST, OPT_ffast_math, NULL, 1 },
554 { OPT_LEVELS_FAST, OPT_fallow_store_data_races, NULL, 1 },
555
556 { OPT_LEVELS_NONE, 0, NULL, 0 }
557 };
558
559 /* Default the options in OPTS and OPTS_SET based on the optimization
560 settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
561 void
562 default_options_optimization (struct gcc_options *opts,
563 struct gcc_options *opts_set,
564 struct cl_decoded_option *decoded_options,
565 unsigned int decoded_options_count,
566 location_t loc,
567 unsigned int lang_mask,
568 const struct cl_option_handlers *handlers,
569 diagnostic_context *dc)
570 {
571 unsigned int i;
572 int opt2;
573 bool openacc_mode = false;
574
575 /* Scan to see what optimization level has been specified. That will
576 determine the default value of many flags. */
577 for (i = 1; i < decoded_options_count; i++)
578 {
579 struct cl_decoded_option *opt = &decoded_options[i];
580 switch (opt->opt_index)
581 {
582 case OPT_O:
583 if (*opt->arg == '\0')
584 {
585 opts->x_optimize = 1;
586 opts->x_optimize_size = 0;
587 opts->x_optimize_fast = 0;
588 opts->x_optimize_debug = 0;
589 }
590 else
591 {
592 const int optimize_val = integral_argument (opt->arg);
593 if (optimize_val == -1)
594 error_at (loc, "argument to %<-O%> should be a non-negative "
595 "integer, %<g%>, %<s%> or %<fast%>");
596 else
597 {
598 opts->x_optimize = optimize_val;
599 if ((unsigned int) opts->x_optimize > 255)
600 opts->x_optimize = 255;
601 opts->x_optimize_size = 0;
602 opts->x_optimize_fast = 0;
603 opts->x_optimize_debug = 0;
604 }
605 }
606 break;
607
608 case OPT_Os:
609 opts->x_optimize_size = 1;
610
611 /* Optimizing for size forces optimize to be 2. */
612 opts->x_optimize = 2;
613 opts->x_optimize_fast = 0;
614 opts->x_optimize_debug = 0;
615 break;
616
617 case OPT_Ofast:
618 /* -Ofast only adds flags to -O3. */
619 opts->x_optimize_size = 0;
620 opts->x_optimize = 3;
621 opts->x_optimize_fast = 1;
622 opts->x_optimize_debug = 0;
623 break;
624
625 case OPT_Og:
626 /* -Og selects optimization level 1. */
627 opts->x_optimize_size = 0;
628 opts->x_optimize = 1;
629 opts->x_optimize_fast = 0;
630 opts->x_optimize_debug = 1;
631 break;
632
633 case OPT_fopenacc:
634 if (opt->value)
635 openacc_mode = true;
636 break;
637
638 default:
639 /* Ignore other options in this prescan. */
640 break;
641 }
642 }
643
644 maybe_default_options (opts, opts_set, default_options_table,
645 opts->x_optimize, opts->x_optimize_size,
646 opts->x_optimize_fast, opts->x_optimize_debug,
647 lang_mask, handlers, loc, dc);
648
649 /* -O2 param settings. */
650 opt2 = (opts->x_optimize >= 2);
651
652 if (openacc_mode)
653 SET_OPTION_IF_UNSET (opts, opts_set, flag_ipa_pta, true);
654
655 /* Track fields in field-sensitive alias analysis. */
656 if (opt2)
657 SET_OPTION_IF_UNSET (opts, opts_set, param_max_fields_for_field_sensitive,
658 100);
659
660 if (opts->x_optimize_size)
661 /* We want to crossjump as much as possible. */
662 SET_OPTION_IF_UNSET (opts, opts_set, param_min_crossjump_insns, 1);
663
664 /* Restrict the amount of work combine does at -Og while retaining
665 most of its useful transforms. */
666 if (opts->x_optimize_debug)
667 SET_OPTION_IF_UNSET (opts, opts_set, param_max_combine_insns, 2);
668
669 /* Allow default optimizations to be specified on a per-machine basis. */
670 maybe_default_options (opts, opts_set,
671 targetm_common.option_optimization_table,
672 opts->x_optimize, opts->x_optimize_size,
673 opts->x_optimize_fast, opts->x_optimize_debug,
674 lang_mask, handlers, loc, dc);
675 }
676
677 /* Control IPA optimizations based on different live patching LEVEL. */
678 static void
679 control_options_for_live_patching (struct gcc_options *opts,
680 struct gcc_options *opts_set,
681 enum live_patching_level level,
682 location_t loc)
683 {
684 gcc_assert (level > LIVE_PATCHING_NONE);
685
686 switch (level)
687 {
688 case LIVE_PATCHING_INLINE_ONLY_STATIC:
689 if (opts_set->x_flag_ipa_cp_clone && opts->x_flag_ipa_cp_clone)
690 error_at (loc,
691 "%<-fipa-cp-clone%> is incompatible with "
692 "%<-flive-patching=inline-only-static%>");
693 else
694 opts->x_flag_ipa_cp_clone = 0;
695
696 if (opts_set->x_flag_ipa_sra && opts->x_flag_ipa_sra)
697 error_at (loc,
698 "%<-fipa-sra%> is incompatible with "
699 "%<-flive-patching=inline-only-static%>");
700 else
701 opts->x_flag_ipa_sra = 0;
702
703 if (opts_set->x_flag_partial_inlining && opts->x_flag_partial_inlining)
704 error_at (loc,
705 "%<-fpartial-inlining%> is incompatible with "
706 "%<-flive-patching=inline-only-static%>");
707 else
708 opts->x_flag_partial_inlining = 0;
709
710 if (opts_set->x_flag_ipa_cp && opts->x_flag_ipa_cp)
711 error_at (loc,
712 "%<-fipa-cp%> is incompatible with "
713 "%<-flive-patching=inline-only-static%>");
714 else
715 opts->x_flag_ipa_cp = 0;
716
717 /* FALLTHROUGH. */
718 case LIVE_PATCHING_INLINE_CLONE:
719 /* live patching should disable whole-program optimization. */
720 if (opts_set->x_flag_whole_program && opts->x_flag_whole_program)
721 error_at (loc,
722 "%<-fwhole-program%> is incompatible with "
723 "%<-flive-patching=inline-only-static|inline-clone%>");
724 else
725 opts->x_flag_whole_program = 0;
726
727 /* visibility change should be excluded by !flag_whole_program
728 && !in_lto_p && !flag_ipa_cp_clone && !flag_ipa_sra
729 && !flag_partial_inlining. */
730
731 if (opts_set->x_flag_ipa_pta && opts->x_flag_ipa_pta)
732 error_at (loc,
733 "%<-fipa-pta%> is incompatible with "
734 "%<-flive-patching=inline-only-static|inline-clone%>");
735 else
736 opts->x_flag_ipa_pta = 0;
737
738 if (opts_set->x_flag_ipa_reference && opts->x_flag_ipa_reference)
739 error_at (loc,
740 "%<-fipa-reference%> is incompatible with "
741 "%<-flive-patching=inline-only-static|inline-clone%>");
742 else
743 opts->x_flag_ipa_reference = 0;
744
745 if (opts_set->x_flag_ipa_ra && opts->x_flag_ipa_ra)
746 error_at (loc,
747 "%<-fipa-ra%> is incompatible with "
748 "%<-flive-patching=inline-only-static|inline-clone%>");
749 else
750 opts->x_flag_ipa_ra = 0;
751
752 if (opts_set->x_flag_ipa_icf && opts->x_flag_ipa_icf)
753 error_at (loc,
754 "%<-fipa-icf%> is incompatible with "
755 "%<-flive-patching=inline-only-static|inline-clone%>");
756 else
757 opts->x_flag_ipa_icf = 0;
758
759 if (opts_set->x_flag_ipa_icf_functions && opts->x_flag_ipa_icf_functions)
760 error_at (loc,
761 "%<-fipa-icf-functions%> is incompatible with "
762 "%<-flive-patching=inline-only-static|inline-clone%>");
763 else
764 opts->x_flag_ipa_icf_functions = 0;
765
766 if (opts_set->x_flag_ipa_icf_variables && opts->x_flag_ipa_icf_variables)
767 error_at (loc,
768 "%<-fipa-icf-variables%> is incompatible with "
769 "%<-flive-patching=inline-only-static|inline-clone%>");
770 else
771 opts->x_flag_ipa_icf_variables = 0;
772
773 if (opts_set->x_flag_ipa_bit_cp && opts->x_flag_ipa_bit_cp)
774 error_at (loc,
775 "%<-fipa-bit-cp%> is incompatible with "
776 "%<-flive-patching=inline-only-static|inline-clone%>");
777 else
778 opts->x_flag_ipa_bit_cp = 0;
779
780 if (opts_set->x_flag_ipa_vrp && opts->x_flag_ipa_vrp)
781 error_at (loc,
782 "%<-fipa-vrp%> is incompatible with "
783 "%<-flive-patching=inline-only-static|inline-clone%>");
784 else
785 opts->x_flag_ipa_vrp = 0;
786
787 if (opts_set->x_flag_ipa_pure_const && opts->x_flag_ipa_pure_const)
788 error_at (loc,
789 "%<-fipa-pure-const%> is incompatible with "
790 "%<-flive-patching=inline-only-static|inline-clone%>");
791 else
792 opts->x_flag_ipa_pure_const = 0;
793
794 /* FIXME: disable unreachable code removal. */
795
796 /* discovery of functions/variables with no address taken. */
797 if (opts_set->x_flag_ipa_reference_addressable
798 && opts->x_flag_ipa_reference_addressable)
799 error_at (loc,
800 "%<-fipa-reference-addressable%> is incompatible with "
801 "%<-flive-patching=inline-only-static|inline-clone%>");
802 else
803 opts->x_flag_ipa_reference_addressable = 0;
804
805 /* ipa stack alignment propagation. */
806 if (opts_set->x_flag_ipa_stack_alignment
807 && opts->x_flag_ipa_stack_alignment)
808 error_at (loc,
809 "%<-fipa-stack-alignment%> is incompatible with "
810 "%<-flive-patching=inline-only-static|inline-clone%>");
811 else
812 opts->x_flag_ipa_stack_alignment = 0;
813 break;
814 default:
815 gcc_unreachable ();
816 }
817 }
818
819 /* --help option argument if set. */
820 vec<const char *> help_option_arguments;
821
822
823 /* After all options at LOC have been read into OPTS and OPTS_SET,
824 finalize settings of those options and diagnose incompatible
825 combinations. */
826 void
827 finish_options (struct gcc_options *opts, struct gcc_options *opts_set,
828 location_t loc)
829 {
830 enum unwind_info_type ui_except;
831
832 if (opts->x_dump_base_name
833 && ! opts->x_dump_base_name_prefixed)
834 {
835 const char *sep = opts->x_dump_base_name;
836
837 for (; *sep; sep++)
838 if (IS_DIR_SEPARATOR (*sep))
839 break;
840
841 if (*sep)
842 /* If dump_base_path contains subdirectories, don't prepend
843 anything. */;
844 else if (opts->x_dump_dir_name)
845 /* We have a DUMP_DIR_NAME, prepend that. */
846 opts->x_dump_base_name = opts_concat (opts->x_dump_dir_name,
847 opts->x_dump_base_name, NULL);
848
849 /* It is definitely prefixed now. */
850 opts->x_dump_base_name_prefixed = true;
851 }
852
853 /* Handle related options for unit-at-a-time, toplevel-reorder, and
854 section-anchors. */
855 if (!opts->x_flag_unit_at_a_time)
856 {
857 if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
858 error_at (loc, "section anchors must be disabled when unit-at-a-time "
859 "is disabled");
860 opts->x_flag_section_anchors = 0;
861 if (opts->x_flag_toplevel_reorder == 1)
862 error_at (loc, "toplevel reorder must be disabled when unit-at-a-time "
863 "is disabled");
864 opts->x_flag_toplevel_reorder = 0;
865 }
866
867 /* -fself-test depends on the state of the compiler prior to
868 compiling anything. Ideally it should be run on an empty source
869 file. However, in case we get run with actual source, assume
870 -fsyntax-only which will inhibit any compiler initialization
871 which may confuse the self tests. */
872 if (opts->x_flag_self_test)
873 opts->x_flag_syntax_only = 1;
874
875 if (opts->x_flag_tm && opts->x_flag_non_call_exceptions)
876 sorry ("transactional memory is not supported with non-call exceptions");
877
878 /* Unless the user has asked for section anchors, we disable toplevel
879 reordering at -O0 to disable transformations that might be surprising
880 to end users and to get -fno-toplevel-reorder tested. */
881 if (!opts->x_optimize
882 && opts->x_flag_toplevel_reorder == 2
883 && !(opts->x_flag_section_anchors && opts_set->x_flag_section_anchors))
884 {
885 opts->x_flag_toplevel_reorder = 0;
886 opts->x_flag_section_anchors = 0;
887 }
888 if (!opts->x_flag_toplevel_reorder)
889 {
890 if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
891 error_at (loc, "section anchors must be disabled when toplevel reorder"
892 " is disabled");
893 opts->x_flag_section_anchors = 0;
894 }
895
896 if (!opts->x_flag_opts_finished)
897 {
898 /* We initialize opts->x_flag_pie to -1 so that targets can set a
899 default value. */
900 if (opts->x_flag_pie == -1)
901 {
902 /* We initialize opts->x_flag_pic to -1 so that we can tell if
903 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
904 if (opts->x_flag_pic == -1)
905 opts->x_flag_pie = DEFAULT_FLAG_PIE;
906 else
907 opts->x_flag_pie = 0;
908 }
909 /* If -fPIE or -fpie is used, turn on PIC. */
910 if (opts->x_flag_pie)
911 opts->x_flag_pic = opts->x_flag_pie;
912 else if (opts->x_flag_pic == -1)
913 opts->x_flag_pic = 0;
914 if (opts->x_flag_pic && !opts->x_flag_pie)
915 opts->x_flag_shlib = 1;
916 opts->x_flag_opts_finished = true;
917 }
918
919 /* We initialize opts->x_flag_stack_protect to -1 so that targets
920 can set a default value. */
921 if (opts->x_flag_stack_protect == -1)
922 opts->x_flag_stack_protect = DEFAULT_FLAG_SSP;
923
924 if (opts->x_optimize == 0)
925 {
926 /* Inlining does not work if not optimizing,
927 so force it not to be done. */
928 opts->x_warn_inline = 0;
929 opts->x_flag_no_inline = 1;
930 }
931
932 /* The optimization to partition hot and cold basic blocks into separate
933 sections of the .o and executable files does not work (currently)
934 with exception handling. This is because there is no support for
935 generating unwind info. If opts->x_flag_exceptions is turned on
936 we need to turn off the partitioning optimization. */
937
938 ui_except = targetm_common.except_unwind_info (opts);
939
940 if (opts->x_flag_exceptions
941 && opts->x_flag_reorder_blocks_and_partition
942 && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))
943 {
944 if (opts_set->x_flag_reorder_blocks_and_partition)
945 inform (loc,
946 "%<-freorder-blocks-and-partition%> does not work "
947 "with exceptions on this architecture");
948 opts->x_flag_reorder_blocks_and_partition = 0;
949 opts->x_flag_reorder_blocks = 1;
950 }
951
952 /* If user requested unwind info, then turn off the partitioning
953 optimization. */
954
955 if (opts->x_flag_unwind_tables
956 && !targetm_common.unwind_tables_default
957 && opts->x_flag_reorder_blocks_and_partition
958 && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))
959 {
960 if (opts_set->x_flag_reorder_blocks_and_partition)
961 inform (loc,
962 "%<-freorder-blocks-and-partition%> does not support "
963 "unwind info on this architecture");
964 opts->x_flag_reorder_blocks_and_partition = 0;
965 opts->x_flag_reorder_blocks = 1;
966 }
967
968 /* If the target requested unwind info, then turn off the partitioning
969 optimization with a different message. Likewise, if the target does not
970 support named sections. */
971
972 if (opts->x_flag_reorder_blocks_and_partition
973 && (!targetm_common.have_named_sections
974 || (opts->x_flag_unwind_tables
975 && targetm_common.unwind_tables_default
976 && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))))
977 {
978 if (opts_set->x_flag_reorder_blocks_and_partition)
979 inform (loc,
980 "%<-freorder-blocks-and-partition%> does not work "
981 "on this architecture");
982 opts->x_flag_reorder_blocks_and_partition = 0;
983 opts->x_flag_reorder_blocks = 1;
984 }
985
986
987 /* Pipelining of outer loops is only possible when general pipelining
988 capabilities are requested. */
989 if (!opts->x_flag_sel_sched_pipelining)
990 opts->x_flag_sel_sched_pipelining_outer_loops = 0;
991
992 if (opts->x_flag_conserve_stack)
993 {
994 SET_OPTION_IF_UNSET (opts, opts_set, param_large_stack_frame, 100);
995 SET_OPTION_IF_UNSET (opts, opts_set, param_stack_frame_growth, 40);
996 }
997
998 if (opts->x_flag_lto)
999 {
1000 #ifdef ENABLE_LTO
1001 opts->x_flag_generate_lto = 1;
1002
1003 /* When generating IL, do not operate in whole-program mode.
1004 Otherwise, symbols will be privatized too early, causing link
1005 errors later. */
1006 opts->x_flag_whole_program = 0;
1007 #else
1008 error_at (loc, "LTO support has not been enabled in this configuration");
1009 #endif
1010 if (!opts->x_flag_fat_lto_objects
1011 && (!HAVE_LTO_PLUGIN
1012 || (opts_set->x_flag_use_linker_plugin
1013 && !opts->x_flag_use_linker_plugin)))
1014 {
1015 if (opts_set->x_flag_fat_lto_objects)
1016 error_at (loc, "%<-fno-fat-lto-objects%> are supported only with "
1017 "linker plugin");
1018 opts->x_flag_fat_lto_objects = 1;
1019 }
1020
1021 /* -gsplit-dwarf isn't compatible with LTO, see PR88389. */
1022 if (opts->x_dwarf_split_debug_info)
1023 {
1024 inform (loc, "%<-gsplit-dwarf%> is not supported with LTO,"
1025 " disabling");
1026 opts->x_dwarf_split_debug_info = 0;
1027 }
1028 }
1029
1030 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
1031 default value if they choose based on other options. */
1032 if (opts->x_flag_split_stack == -1)
1033 opts->x_flag_split_stack = 0;
1034 else if (opts->x_flag_split_stack)
1035 {
1036 if (!targetm_common.supports_split_stack (true, opts))
1037 {
1038 error_at (loc, "%<-fsplit-stack%> is not supported by "
1039 "this compiler configuration");
1040 opts->x_flag_split_stack = 0;
1041 }
1042 }
1043
1044 /* If stack splitting is turned on, and the user did not explicitly
1045 request function partitioning, turn off partitioning, as it
1046 confuses the linker when trying to handle partitioned split-stack
1047 code that calls a non-split-stack functions. But if partitioning
1048 was turned on explicitly just hope for the best. */
1049 if (opts->x_flag_split_stack
1050 && opts->x_flag_reorder_blocks_and_partition)
1051 SET_OPTION_IF_UNSET (opts, opts_set, flag_reorder_blocks_and_partition, 0);
1052
1053 if (opts->x_flag_reorder_blocks_and_partition)
1054 SET_OPTION_IF_UNSET (opts, opts_set, flag_reorder_functions, 1);
1055
1056 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
1057 if (opts->x_dwarf_split_debug_info)
1058 opts->x_debug_generate_pub_sections = 2;
1059
1060 if ((opts->x_flag_sanitize
1061 & (SANITIZE_USER_ADDRESS | SANITIZE_KERNEL_ADDRESS)) == 0)
1062 {
1063 if (opts->x_flag_sanitize & SANITIZE_POINTER_COMPARE)
1064 error_at (loc,
1065 "%<-fsanitize=pointer-compare%> must be combined with "
1066 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1067 if (opts->x_flag_sanitize & SANITIZE_POINTER_SUBTRACT)
1068 error_at (loc,
1069 "%<-fsanitize=pointer-subtract%> must be combined with "
1070 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1071 }
1072
1073 /* Userspace and kernel ASan conflict with each other. */
1074 if ((opts->x_flag_sanitize & SANITIZE_USER_ADDRESS)
1075 && (opts->x_flag_sanitize & SANITIZE_KERNEL_ADDRESS))
1076 error_at (loc,
1077 "%<-fsanitize=address%> is incompatible with "
1078 "%<-fsanitize=kernel-address%>");
1079
1080 /* And with TSan. */
1081 if ((opts->x_flag_sanitize & SANITIZE_ADDRESS)
1082 && (opts->x_flag_sanitize & SANITIZE_THREAD))
1083 error_at (loc,
1084 "%<-fsanitize=address%> and %<-fsanitize=kernel-address%> "
1085 "are incompatible with %<-fsanitize=thread%>");
1086
1087 if ((opts->x_flag_sanitize & SANITIZE_LEAK)
1088 && (opts->x_flag_sanitize & SANITIZE_THREAD))
1089 error_at (loc,
1090 "%<-fsanitize=leak%> is incompatible with %<-fsanitize=thread%>");
1091
1092 /* Check error recovery for -fsanitize-recover option. */
1093 for (int i = 0; sanitizer_opts[i].name != NULL; ++i)
1094 if ((opts->x_flag_sanitize_recover & sanitizer_opts[i].flag)
1095 && !sanitizer_opts[i].can_recover)
1096 error_at (loc, "%<-fsanitize-recover=%s%> is not supported",
1097 sanitizer_opts[i].name);
1098
1099 /* When instrumenting the pointers, we don't want to remove
1100 the null pointer checks. */
1101 if (opts->x_flag_sanitize & (SANITIZE_NULL | SANITIZE_NONNULL_ATTRIBUTE
1102 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE))
1103 opts->x_flag_delete_null_pointer_checks = 0;
1104
1105 /* Aggressive compiler optimizations may cause false negatives. */
1106 if (opts->x_flag_sanitize & ~(SANITIZE_LEAK | SANITIZE_UNREACHABLE))
1107 opts->x_flag_aggressive_loop_optimizations = 0;
1108
1109 /* Enable -fsanitize-address-use-after-scope if address sanitizer is
1110 enabled. */
1111 if (opts->x_flag_sanitize & SANITIZE_USER_ADDRESS)
1112 SET_OPTION_IF_UNSET (opts, opts_set, flag_sanitize_address_use_after_scope,
1113 true);
1114
1115 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1116 is enabled. */
1117 if (opts->x_flag_sanitize_address_use_after_scope)
1118 {
1119 if (opts->x_flag_stack_reuse != SR_NONE
1120 && opts_set->x_flag_stack_reuse != SR_NONE)
1121 error_at (loc,
1122 "%<-fsanitize-address-use-after-scope%> requires "
1123 "%<-fstack-reuse=none%> option");
1124
1125 opts->x_flag_stack_reuse = SR_NONE;
1126 }
1127
1128 if ((opts->x_flag_sanitize & SANITIZE_USER_ADDRESS) && opts->x_flag_tm)
1129 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1130
1131 if ((opts->x_flag_sanitize & SANITIZE_KERNEL_ADDRESS) && opts->x_flag_tm)
1132 sorry ("transactional memory is not supported with "
1133 "%<-fsanitize=kernel-address%>");
1134
1135 /* Currently live patching is not support for LTO. */
1136 if (opts->x_flag_live_patching && opts->x_flag_lto)
1137 sorry ("live patching is not supported with LTO");
1138
1139 /* Currently vtable verification is not supported for LTO */
1140 if (opts->x_flag_vtable_verify && opts->x_flag_lto)
1141 sorry ("vtable verification is not supported with LTO");
1142
1143 /* Control IPA optimizations based on different -flive-patching level. */
1144 if (opts->x_flag_live_patching)
1145 control_options_for_live_patching (opts, opts_set,
1146 opts->x_flag_live_patching,
1147 loc);
1148
1149 /* Unrolling all loops implies that standard loop unrolling must also
1150 be done. */
1151 if (opts->x_flag_unroll_all_loops)
1152 opts->x_flag_unroll_loops = 1;
1153
1154 /* Allow cunroll to grow size accordingly. */
1155 if (!opts_set->x_flag_cunroll_grow_size)
1156 opts->x_flag_cunroll_grow_size
1157 = (opts->x_flag_unroll_loops
1158 || opts->x_flag_peel_loops
1159 || opts->x_optimize >= 3);
1160 }
1161
1162 #define LEFT_COLUMN 27
1163
1164 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1165 followed by word-wrapped HELP in a second column. */
1166 static void
1167 wrap_help (const char *help,
1168 const char *item,
1169 unsigned int item_width,
1170 unsigned int columns)
1171 {
1172 unsigned int col_width = LEFT_COLUMN;
1173 unsigned int remaining, room, len;
1174
1175 remaining = strlen (help);
1176
1177 do
1178 {
1179 room = columns - 3 - MAX (col_width, item_width);
1180 if (room > columns)
1181 room = 0;
1182 len = remaining;
1183
1184 if (room < len)
1185 {
1186 unsigned int i;
1187
1188 for (i = 0; help[i]; i++)
1189 {
1190 if (i >= room && len != remaining)
1191 break;
1192 if (help[i] == ' ')
1193 len = i;
1194 else if ((help[i] == '-' || help[i] == '/')
1195 && help[i + 1] != ' '
1196 && i > 0 && ISALPHA (help[i - 1]))
1197 len = i + 1;
1198 }
1199 }
1200
1201 printf (" %-*.*s %.*s\n", col_width, item_width, item, len, help);
1202 item_width = 0;
1203 while (help[len] == ' ')
1204 len++;
1205 help += len;
1206 remaining -= len;
1207 }
1208 while (remaining);
1209 }
1210
1211 /* Data structure used to print list of valid option values. */
1212
1213 class option_help_tuple
1214 {
1215 public:
1216 option_help_tuple (int code, vec<const char *> values):
1217 m_code (code), m_values (values)
1218 {}
1219
1220 /* Code of an option. */
1221 int m_code;
1222
1223 /* List of possible values. */
1224 vec<const char *> m_values;
1225 };
1226
1227 /* Print help for a specific front-end, etc. */
1228 static void
1229 print_filtered_help (unsigned int include_flags,
1230 unsigned int exclude_flags,
1231 unsigned int any_flags,
1232 unsigned int columns,
1233 struct gcc_options *opts,
1234 unsigned int lang_mask)
1235 {
1236 unsigned int i;
1237 const char *help;
1238 bool found = false;
1239 bool displayed = false;
1240 char new_help[256];
1241
1242 if (!opts->x_help_printed)
1243 opts->x_help_printed = XCNEWVAR (char, cl_options_count);
1244
1245 if (!opts->x_help_enum_printed)
1246 opts->x_help_enum_printed = XCNEWVAR (char, cl_enums_count);
1247
1248 auto_vec<option_help_tuple> help_tuples;
1249
1250 for (i = 0; i < cl_options_count; i++)
1251 {
1252 const struct cl_option *option = cl_options + i;
1253 unsigned int len;
1254 const char *opt;
1255 const char *tab;
1256
1257 if (include_flags == 0
1258 || ((option->flags & include_flags) != include_flags))
1259 {
1260 if ((option->flags & any_flags) == 0)
1261 continue;
1262 }
1263
1264 /* Skip unwanted switches. */
1265 if ((option->flags & exclude_flags) != 0)
1266 continue;
1267
1268 /* The driver currently prints its own help text. */
1269 if ((option->flags & CL_DRIVER) != 0
1270 && (option->flags & (((1U << cl_lang_count) - 1)
1271 | CL_COMMON | CL_TARGET)) == 0)
1272 continue;
1273
1274 /* If an option contains a language specification,
1275 exclude it from common unless all languages are present. */
1276 if ((include_flags & CL_COMMON)
1277 && !(option->flags & CL_DRIVER)
1278 && (option->flags & CL_LANG_ALL)
1279 && (option->flags & CL_LANG_ALL) != CL_LANG_ALL)
1280 continue;
1281
1282 found = true;
1283 /* Skip switches that have already been printed. */
1284 if (opts->x_help_printed[i])
1285 continue;
1286
1287 opts->x_help_printed[i] = true;
1288
1289 help = option->help;
1290 if (help == NULL)
1291 {
1292 if (exclude_flags & CL_UNDOCUMENTED)
1293 continue;
1294
1295 help = undocumented_msg;
1296 }
1297
1298 /* Get the translation. */
1299 help = _(help);
1300
1301 if (option->alias_target < N_OPTS
1302 && cl_options [option->alias_target].help)
1303 {
1304 const struct cl_option *target = cl_options + option->alias_target;
1305 if (option->help == NULL)
1306 {
1307 /* The option is undocumented but is an alias for an option that
1308 is documented. If the option has alias arguments, then its
1309 purpose is to provide certain arguments to the other option, so
1310 inform the reader of this. Otherwise, point the reader to the
1311 other option in preference to the former. */
1312
1313 if (option->alias_arg)
1314 {
1315 if (option->neg_alias_arg)
1316 snprintf (new_help, sizeof new_help,
1317 _("Same as %s%s (or, in negated form, %s%s)."),
1318 target->opt_text, option->alias_arg,
1319 target->opt_text, option->neg_alias_arg);
1320 else
1321 snprintf (new_help, sizeof new_help,
1322 _("Same as %s%s."),
1323 target->opt_text, option->alias_arg);
1324 }
1325 else
1326 snprintf (new_help, sizeof new_help,
1327 _("Same as %s."),
1328 target->opt_text);
1329 }
1330 else
1331 {
1332 /* For documented options with aliases, mention the aliased
1333 option's name for reference. */
1334 snprintf (new_help, sizeof new_help,
1335 _("%s Same as %s."),
1336 help, cl_options [option->alias_target].opt_text);
1337 }
1338
1339 help = new_help;
1340 }
1341
1342 if (option->warn_message)
1343 {
1344 /* Mention that the use of the option will trigger a warning. */
1345 if (help == new_help)
1346 snprintf (new_help + strlen (new_help),
1347 sizeof new_help - strlen (new_help),
1348 " %s", _(use_diagnosed_msg));
1349 else
1350 snprintf (new_help, sizeof new_help,
1351 "%s %s", help, _(use_diagnosed_msg));
1352
1353 help = new_help;
1354 }
1355
1356 /* Find the gap between the name of the
1357 option and its descriptive text. */
1358 tab = strchr (help, '\t');
1359 if (tab)
1360 {
1361 len = tab - help;
1362 opt = help;
1363 help = tab + 1;
1364 }
1365 else
1366 {
1367 opt = option->opt_text;
1368 len = strlen (opt);
1369 }
1370
1371 /* With the -Q option enabled we change the descriptive text associated
1372 with an option to be an indication of its current setting. */
1373 if (!opts->x_quiet_flag)
1374 {
1375 void *flag_var = option_flag_var (i, opts);
1376
1377 if (len < (LEFT_COLUMN + 2))
1378 strcpy (new_help, "\t\t");
1379 else
1380 strcpy (new_help, "\t");
1381
1382 /* Set to print whether the option is enabled or disabled,
1383 or, if it's an alias for another option, the name of
1384 the aliased option. */
1385 bool print_state = false;
1386
1387 if (flag_var != NULL
1388 && option->var_type != CLVC_DEFER)
1389 {
1390 /* If OPTION is only available for a specific subset
1391 of languages other than this one, mention them. */
1392 bool avail_for_lang = true;
1393 if (unsigned langset = option->flags & CL_LANG_ALL)
1394 {
1395 if (!(langset & lang_mask))
1396 {
1397 avail_for_lang = false;
1398 strcat (new_help, _("[available in "));
1399 for (unsigned i = 0, n = 0; (1U << i) < CL_LANG_ALL; ++i)
1400 if (langset & (1U << i))
1401 {
1402 if (n++)
1403 strcat (new_help, ", ");
1404 strcat (new_help, lang_names[i]);
1405 }
1406 strcat (new_help, "]");
1407 }
1408 }
1409 if (!avail_for_lang)
1410 ; /* Print nothing else if the option is not available
1411 in the current language. */
1412 else if (option->flags & CL_JOINED)
1413 {
1414 if (option->var_type == CLVC_STRING)
1415 {
1416 if (* (const char **) flag_var != NULL)
1417 snprintf (new_help + strlen (new_help),
1418 sizeof (new_help) - strlen (new_help),
1419 "%s", * (const char **) flag_var);
1420 }
1421 else if (option->var_type == CLVC_ENUM)
1422 {
1423 const struct cl_enum *e = &cl_enums[option->var_enum];
1424 int value;
1425 const char *arg = NULL;
1426
1427 value = e->get (flag_var);
1428 enum_value_to_arg (e->values, &arg, value, lang_mask);
1429 if (arg == NULL)
1430 arg = _("[default]");
1431 snprintf (new_help + strlen (new_help),
1432 sizeof (new_help) - strlen (new_help),
1433 "%s", arg);
1434 }
1435 else
1436 {
1437 if (option->cl_host_wide_int)
1438 sprintf (new_help + strlen (new_help),
1439 _("%llu bytes"), (unsigned long long)
1440 *(unsigned HOST_WIDE_INT *) flag_var);
1441 else
1442 sprintf (new_help + strlen (new_help),
1443 "%i", * (int *) flag_var);
1444 }
1445 }
1446 else
1447 print_state = true;
1448 }
1449 else
1450 /* When there is no argument, print the option state only
1451 if the option takes no argument. */
1452 print_state = !(option->flags & CL_JOINED);
1453
1454 if (print_state)
1455 {
1456 if (option->alias_target < N_OPTS
1457 && option->alias_target != OPT_SPECIAL_warn_removed
1458 && option->alias_target != OPT_SPECIAL_ignore
1459 && option->alias_target != OPT_SPECIAL_input_file
1460 && option->alias_target != OPT_SPECIAL_program_name
1461 && option->alias_target != OPT_SPECIAL_unknown)
1462 {
1463 const struct cl_option *target
1464 = &cl_options[option->alias_target];
1465 sprintf (new_help + strlen (new_help), "%s%s",
1466 target->opt_text,
1467 option->alias_arg ? option->alias_arg : "");
1468 }
1469 else if (option->alias_target == OPT_SPECIAL_ignore)
1470 strcat (new_help, ("[ignored]"));
1471 else
1472 {
1473 /* Print the state for an on/off option. */
1474 int ena = option_enabled (i, lang_mask, opts);
1475 if (ena > 0)
1476 strcat (new_help, _("[enabled]"));
1477 else if (ena == 0)
1478 strcat (new_help, _("[disabled]"));
1479 }
1480 }
1481
1482 help = new_help;
1483 }
1484
1485 if (option->range_max != -1)
1486 {
1487 char b[128];
1488 snprintf (b, sizeof (b), "<%d,%d>", option->range_min,
1489 option->range_max);
1490 opt = concat (opt, b, NULL);
1491 len += strlen (b);
1492 }
1493
1494 wrap_help (help, opt, len, columns);
1495 displayed = true;
1496
1497 if (option->var_type == CLVC_ENUM
1498 && opts->x_help_enum_printed[option->var_enum] != 2)
1499 opts->x_help_enum_printed[option->var_enum] = 1;
1500 else
1501 {
1502 vec<const char *> option_values
1503 = targetm_common.get_valid_option_values (i, NULL);
1504 if (!option_values.is_empty ())
1505 help_tuples.safe_push (option_help_tuple (i, option_values));
1506 }
1507 }
1508
1509 if (! found)
1510 {
1511 unsigned int langs = include_flags & CL_LANG_ALL;
1512
1513 if (langs == 0)
1514 printf (_(" No options with the desired characteristics were found\n"));
1515 else
1516 {
1517 unsigned int i;
1518
1519 /* PR 31349: Tell the user how to see all of the
1520 options supported by a specific front end. */
1521 for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1522 if ((1U << i) & langs)
1523 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1524 lang_names[i], lang_names[i]);
1525 }
1526
1527 }
1528 else if (! displayed)
1529 printf (_(" All options with the desired characteristics have already been displayed\n"));
1530
1531 putchar ('\n');
1532
1533 /* Print details of enumerated option arguments, if those
1534 enumerations have help text headings provided. If no help text
1535 is provided, presume that the possible values are listed in the
1536 help text for the relevant options. */
1537 for (i = 0; i < cl_enums_count; i++)
1538 {
1539 unsigned int j, pos;
1540
1541 if (opts->x_help_enum_printed[i] != 1)
1542 continue;
1543 if (cl_enums[i].help == NULL)
1544 continue;
1545 printf (" %s\n ", _(cl_enums[i].help));
1546 pos = 4;
1547 for (j = 0; cl_enums[i].values[j].arg != NULL; j++)
1548 {
1549 unsigned int len = strlen (cl_enums[i].values[j].arg);
1550
1551 if (pos > 4 && pos + 1 + len <= columns)
1552 {
1553 printf (" %s", cl_enums[i].values[j].arg);
1554 pos += 1 + len;
1555 }
1556 else
1557 {
1558 if (pos > 4)
1559 {
1560 printf ("\n ");
1561 pos = 4;
1562 }
1563 printf ("%s", cl_enums[i].values[j].arg);
1564 pos += len;
1565 }
1566 }
1567 printf ("\n\n");
1568 opts->x_help_enum_printed[i] = 2;
1569 }
1570
1571 for (unsigned i = 0; i < help_tuples.length (); i++)
1572 {
1573 const struct cl_option *option = cl_options + help_tuples[i].m_code;
1574 printf (_(" Known valid arguments for %s option:\n "),
1575 option->opt_text);
1576 for (unsigned j = 0; j < help_tuples[i].m_values.length (); j++)
1577 printf (" %s", help_tuples[i].m_values[j]);
1578 printf ("\n\n");
1579 }
1580 }
1581
1582 /* Display help for a specified type of option.
1583 The options must have ALL of the INCLUDE_FLAGS set
1584 ANY of the flags in the ANY_FLAGS set
1585 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1586 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1587 static void
1588 print_specific_help (unsigned int include_flags,
1589 unsigned int exclude_flags,
1590 unsigned int any_flags,
1591 struct gcc_options *opts,
1592 unsigned int lang_mask)
1593 {
1594 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1595 const char * description = NULL;
1596 const char * descrip_extra = "";
1597 size_t i;
1598 unsigned int flag;
1599
1600 /* Sanity check: Make sure that we do not have more
1601 languages than we have bits available to enumerate them. */
1602 gcc_assert ((1U << cl_lang_count) <= CL_MIN_OPTION_CLASS);
1603
1604 /* If we have not done so already, obtain
1605 the desired maximum width of the output. */
1606 if (opts->x_help_columns == 0)
1607 {
1608 opts->x_help_columns = get_terminal_width ();
1609 if (opts->x_help_columns == INT_MAX)
1610 /* Use a reasonable default. */
1611 opts->x_help_columns = 80;
1612 }
1613
1614 /* Decide upon the title for the options that we are going to display. */
1615 for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1616 {
1617 switch (flag & include_flags)
1618 {
1619 case 0:
1620 case CL_DRIVER:
1621 break;
1622
1623 case CL_TARGET:
1624 description = _("The following options are target specific");
1625 break;
1626 case CL_WARNING:
1627 description = _("The following options control compiler warning messages");
1628 break;
1629 case CL_OPTIMIZATION:
1630 description = _("The following options control optimizations");
1631 break;
1632 case CL_COMMON:
1633 description = _("The following options are language-independent");
1634 break;
1635 case CL_PARAMS:
1636 description = _("The following options control parameters");
1637 break;
1638 default:
1639 if (i >= cl_lang_count)
1640 break;
1641 if (exclude_flags & all_langs_mask)
1642 description = _("The following options are specific to just the language ");
1643 else
1644 description = _("The following options are supported by the language ");
1645 descrip_extra = lang_names [i];
1646 break;
1647 }
1648 }
1649
1650 if (description == NULL)
1651 {
1652 if (any_flags == 0)
1653 {
1654 if (include_flags & CL_UNDOCUMENTED)
1655 description = _("The following options are not documented");
1656 else if (include_flags & CL_SEPARATE)
1657 description = _("The following options take separate arguments");
1658 else if (include_flags & CL_JOINED)
1659 description = _("The following options take joined arguments");
1660 else
1661 {
1662 internal_error ("unrecognized %<include_flags 0x%x%> passed "
1663 "to %<print_specific_help%>",
1664 include_flags);
1665 return;
1666 }
1667 }
1668 else
1669 {
1670 if (any_flags & all_langs_mask)
1671 description = _("The following options are language-related");
1672 else
1673 description = _("The following options are language-independent");
1674 }
1675 }
1676
1677 printf ("%s%s:\n", description, descrip_extra);
1678 print_filtered_help (include_flags, exclude_flags, any_flags,
1679 opts->x_help_columns, opts, lang_mask);
1680 }
1681
1682 /* Enable FDO-related flags. */
1683
1684 static void
1685 enable_fdo_optimizations (struct gcc_options *opts,
1686 struct gcc_options *opts_set,
1687 int value)
1688 {
1689 SET_OPTION_IF_UNSET (opts, opts_set, flag_branch_probabilities, value);
1690 SET_OPTION_IF_UNSET (opts, opts_set, flag_profile_values, value);
1691 SET_OPTION_IF_UNSET (opts, opts_set, flag_unroll_loops, value);
1692 SET_OPTION_IF_UNSET (opts, opts_set, flag_peel_loops, value);
1693 SET_OPTION_IF_UNSET (opts, opts_set, flag_tracer, value);
1694 SET_OPTION_IF_UNSET (opts, opts_set, flag_value_profile_transformations,
1695 value);
1696 SET_OPTION_IF_UNSET (opts, opts_set, flag_inline_functions, value);
1697 SET_OPTION_IF_UNSET (opts, opts_set, flag_ipa_cp, value);
1698 if (value)
1699 {
1700 SET_OPTION_IF_UNSET (opts, opts_set, flag_ipa_cp_clone, 1);
1701 SET_OPTION_IF_UNSET (opts, opts_set, flag_ipa_bit_cp, 1);
1702 }
1703 SET_OPTION_IF_UNSET (opts, opts_set, flag_predictive_commoning, value);
1704 SET_OPTION_IF_UNSET (opts, opts_set, flag_split_loops, value);
1705 SET_OPTION_IF_UNSET (opts, opts_set, flag_unswitch_loops, value);
1706 SET_OPTION_IF_UNSET (opts, opts_set, flag_gcse_after_reload, value);
1707 SET_OPTION_IF_UNSET (opts, opts_set, flag_tree_loop_vectorize, value);
1708 SET_OPTION_IF_UNSET (opts, opts_set, flag_tree_slp_vectorize, value);
1709 SET_OPTION_IF_UNSET (opts, opts_set, flag_version_loops_for_strides, value);
1710 SET_OPTION_IF_UNSET (opts, opts_set, flag_vect_cost_model,
1711 VECT_COST_MODEL_DYNAMIC);
1712 SET_OPTION_IF_UNSET (opts, opts_set, flag_tree_loop_distribute_patterns,
1713 value);
1714 SET_OPTION_IF_UNSET (opts, opts_set, flag_loop_interchange, value);
1715 SET_OPTION_IF_UNSET (opts, opts_set, flag_unroll_jam, value);
1716 SET_OPTION_IF_UNSET (opts, opts_set, flag_tree_loop_distribution, value);
1717 }
1718
1719 /* -f{,no-}sanitize{,-recover}= suboptions. */
1720 const struct sanitizer_opts_s sanitizer_opts[] =
1721 {
1722 #define SANITIZER_OPT(name, flags, recover) \
1723 { #name, flags, sizeof #name - 1, recover }
1724 SANITIZER_OPT (address, (SANITIZE_ADDRESS | SANITIZE_USER_ADDRESS), true),
1725 SANITIZER_OPT (kernel-address, (SANITIZE_ADDRESS | SANITIZE_KERNEL_ADDRESS),
1726 true),
1727 SANITIZER_OPT (pointer-compare, SANITIZE_POINTER_COMPARE, true),
1728 SANITIZER_OPT (pointer-subtract, SANITIZE_POINTER_SUBTRACT, true),
1729 SANITIZER_OPT (thread, SANITIZE_THREAD, false),
1730 SANITIZER_OPT (leak, SANITIZE_LEAK, false),
1731 SANITIZER_OPT (shift, SANITIZE_SHIFT, true),
1732 SANITIZER_OPT (shift-base, SANITIZE_SHIFT_BASE, true),
1733 SANITIZER_OPT (shift-exponent, SANITIZE_SHIFT_EXPONENT, true),
1734 SANITIZER_OPT (integer-divide-by-zero, SANITIZE_DIVIDE, true),
1735 SANITIZER_OPT (undefined, SANITIZE_UNDEFINED, true),
1736 SANITIZER_OPT (unreachable, SANITIZE_UNREACHABLE, false),
1737 SANITIZER_OPT (vla-bound, SANITIZE_VLA, true),
1738 SANITIZER_OPT (return, SANITIZE_RETURN, false),
1739 SANITIZER_OPT (null, SANITIZE_NULL, true),
1740 SANITIZER_OPT (signed-integer-overflow, SANITIZE_SI_OVERFLOW, true),
1741 SANITIZER_OPT (bool, SANITIZE_BOOL, true),
1742 SANITIZER_OPT (enum, SANITIZE_ENUM, true),
1743 SANITIZER_OPT (float-divide-by-zero, SANITIZE_FLOAT_DIVIDE, true),
1744 SANITIZER_OPT (float-cast-overflow, SANITIZE_FLOAT_CAST, true),
1745 SANITIZER_OPT (bounds, SANITIZE_BOUNDS, true),
1746 SANITIZER_OPT (bounds-strict, SANITIZE_BOUNDS | SANITIZE_BOUNDS_STRICT, true),
1747 SANITIZER_OPT (alignment, SANITIZE_ALIGNMENT, true),
1748 SANITIZER_OPT (nonnull-attribute, SANITIZE_NONNULL_ATTRIBUTE, true),
1749 SANITIZER_OPT (returns-nonnull-attribute, SANITIZE_RETURNS_NONNULL_ATTRIBUTE,
1750 true),
1751 SANITIZER_OPT (object-size, SANITIZE_OBJECT_SIZE, true),
1752 SANITIZER_OPT (vptr, SANITIZE_VPTR, true),
1753 SANITIZER_OPT (pointer-overflow, SANITIZE_POINTER_OVERFLOW, true),
1754 SANITIZER_OPT (builtin, SANITIZE_BUILTIN, true),
1755 SANITIZER_OPT (all, ~0U, true),
1756 #undef SANITIZER_OPT
1757 { NULL, 0U, 0UL, false }
1758 };
1759
1760 /* -f{,no-}sanitize-coverage= suboptions. */
1761 const struct sanitizer_opts_s coverage_sanitizer_opts[] =
1762 {
1763 #define COVERAGE_SANITIZER_OPT(name, flags) \
1764 { #name, flags, sizeof #name - 1, true }
1765 COVERAGE_SANITIZER_OPT (trace-pc, SANITIZE_COV_TRACE_PC),
1766 COVERAGE_SANITIZER_OPT (trace-cmp, SANITIZE_COV_TRACE_CMP),
1767 #undef COVERAGE_SANITIZER_OPT
1768 { NULL, 0U, 0UL, false }
1769 };
1770
1771 /* A struct for describing a run of chars within a string. */
1772
1773 class string_fragment
1774 {
1775 public:
1776 string_fragment (const char *start, size_t len)
1777 : m_start (start), m_len (len) {}
1778
1779 const char *m_start;
1780 size_t m_len;
1781 };
1782
1783 /* Specialization of edit_distance_traits for string_fragment,
1784 for use by get_closest_sanitizer_option. */
1785
1786 template <>
1787 struct edit_distance_traits<const string_fragment &>
1788 {
1789 static size_t get_length (const string_fragment &fragment)
1790 {
1791 return fragment.m_len;
1792 }
1793
1794 static const char *get_string (const string_fragment &fragment)
1795 {
1796 return fragment.m_start;
1797 }
1798 };
1799
1800 /* Given ARG, an unrecognized sanitizer option, return the best
1801 matching sanitizer option, or NULL if there isn't one.
1802 OPTS is array of candidate sanitizer options.
1803 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or
1804 OPT_fsanitize_coverage_.
1805 VALUE is non-zero for the regular form of the option, zero
1806 for the "no-" form (e.g. "-fno-sanitize-recover="). */
1807
1808 static const char *
1809 get_closest_sanitizer_option (const string_fragment &arg,
1810 const struct sanitizer_opts_s *opts,
1811 enum opt_code code, int value)
1812 {
1813 best_match <const string_fragment &, const char*> bm (arg);
1814 for (int i = 0; opts[i].name != NULL; ++i)
1815 {
1816 /* -fsanitize=all is not valid, so don't offer it. */
1817 if (code == OPT_fsanitize_
1818 && opts[i].flag == ~0U
1819 && value)
1820 continue;
1821
1822 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
1823 don't offer the non-recoverable options. */
1824 if (code == OPT_fsanitize_recover_
1825 && !opts[i].can_recover
1826 && value)
1827 continue;
1828
1829 bm.consider (opts[i].name);
1830 }
1831 return bm.get_best_meaningful_candidate ();
1832 }
1833
1834 /* Parse comma separated sanitizer suboptions from P for option SCODE,
1835 adjust previous FLAGS and return new ones. If COMPLAIN is false,
1836 don't issue diagnostics. */
1837
1838 unsigned int
1839 parse_sanitizer_options (const char *p, location_t loc, int scode,
1840 unsigned int flags, int value, bool complain)
1841 {
1842 enum opt_code code = (enum opt_code) scode;
1843
1844 const struct sanitizer_opts_s *opts;
1845 if (code == OPT_fsanitize_coverage_)
1846 opts = coverage_sanitizer_opts;
1847 else
1848 opts = sanitizer_opts;
1849
1850 while (*p != 0)
1851 {
1852 size_t len, i;
1853 bool found = false;
1854 const char *comma = strchr (p, ',');
1855
1856 if (comma == NULL)
1857 len = strlen (p);
1858 else
1859 len = comma - p;
1860 if (len == 0)
1861 {
1862 p = comma + 1;
1863 continue;
1864 }
1865
1866 /* Check to see if the string matches an option class name. */
1867 for (i = 0; opts[i].name != NULL; ++i)
1868 if (len == opts[i].len && memcmp (p, opts[i].name, len) == 0)
1869 {
1870 /* Handle both -fsanitize and -fno-sanitize cases. */
1871 if (value && opts[i].flag == ~0U)
1872 {
1873 if (code == OPT_fsanitize_)
1874 {
1875 if (complain)
1876 error_at (loc, "%<-fsanitize=all%> option is not valid");
1877 }
1878 else
1879 flags |= ~(SANITIZE_THREAD | SANITIZE_LEAK
1880 | SANITIZE_UNREACHABLE | SANITIZE_RETURN);
1881 }
1882 else if (value)
1883 {
1884 /* Do not enable -fsanitize-recover=unreachable and
1885 -fsanitize-recover=return if -fsanitize-recover=undefined
1886 is selected. */
1887 if (code == OPT_fsanitize_recover_
1888 && opts[i].flag == SANITIZE_UNDEFINED)
1889 flags |= (SANITIZE_UNDEFINED
1890 & ~(SANITIZE_UNREACHABLE | SANITIZE_RETURN));
1891 else
1892 flags |= opts[i].flag;
1893 }
1894 else
1895 flags &= ~opts[i].flag;
1896 found = true;
1897 break;
1898 }
1899
1900 if (! found && complain)
1901 {
1902 const char *hint
1903 = get_closest_sanitizer_option (string_fragment (p, len),
1904 opts, code, value);
1905
1906 const char *suffix;
1907 if (code == OPT_fsanitize_recover_)
1908 suffix = "-recover";
1909 else if (code == OPT_fsanitize_coverage_)
1910 suffix = "-coverage";
1911 else
1912 suffix = "";
1913
1914 if (hint)
1915 error_at (loc,
1916 "unrecognized argument to %<-f%ssanitize%s=%> "
1917 "option: %q.*s; did you mean %qs?",
1918 value ? "" : "no-",
1919 suffix, (int) len, p, hint);
1920 else
1921 error_at (loc,
1922 "unrecognized argument to %<-f%ssanitize%s=%> option: "
1923 "%q.*s", value ? "" : "no-",
1924 suffix, (int) len, p);
1925 }
1926
1927 if (comma == NULL)
1928 break;
1929 p = comma + 1;
1930 }
1931 return flags;
1932 }
1933
1934 /* Parse string values of no_sanitize attribute passed in VALUE.
1935 Values are separated with comma. */
1936
1937 unsigned int
1938 parse_no_sanitize_attribute (char *value)
1939 {
1940 unsigned int flags = 0;
1941 unsigned int i;
1942 char *q = strtok (value, ",");
1943
1944 while (q != NULL)
1945 {
1946 for (i = 0; sanitizer_opts[i].name != NULL; ++i)
1947 if (strcmp (sanitizer_opts[i].name, q) == 0)
1948 {
1949 flags |= sanitizer_opts[i].flag;
1950 if (sanitizer_opts[i].flag == SANITIZE_UNDEFINED)
1951 flags |= SANITIZE_UNDEFINED_NONDEFAULT;
1952 break;
1953 }
1954
1955 if (sanitizer_opts[i].name == NULL)
1956 warning (OPT_Wattributes,
1957 "%qs attribute directive ignored", q);
1958
1959 q = strtok (NULL, ",");
1960 }
1961
1962 return flags;
1963 }
1964
1965 /* Parse -falign-NAME format for a FLAG value. Return individual
1966 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
1967 set, print error message at LOC location. */
1968
1969 bool
1970 parse_and_check_align_values (const char *flag,
1971 const char *name,
1972 auto_vec<unsigned> &result_values,
1973 bool report_error,
1974 location_t loc)
1975 {
1976 char *str = xstrdup (flag);
1977 for (char *p = strtok (str, ":"); p; p = strtok (NULL, ":"))
1978 {
1979 char *end;
1980 int v = strtol (p, &end, 10);
1981 if (*end != '\0' || v < 0)
1982 {
1983 if (report_error)
1984 error_at (loc, "invalid arguments for %<-falign-%s%> option: %qs",
1985 name, flag);
1986
1987 return false;
1988 }
1989
1990 result_values.safe_push ((unsigned)v);
1991 }
1992
1993 free (str);
1994
1995 /* Check that we have a correct number of values. */
1996 if (result_values.is_empty () || result_values.length () > 4)
1997 {
1998 if (report_error)
1999 error_at (loc, "invalid number of arguments for %<-falign-%s%> "
2000 "option: %qs", name, flag);
2001 return false;
2002 }
2003
2004 for (unsigned i = 0; i < result_values.length (); i++)
2005 if (result_values[i] > MAX_CODE_ALIGN_VALUE)
2006 {
2007 if (report_error)
2008 error_at (loc, "%<-falign-%s%> is not between 0 and %d",
2009 name, MAX_CODE_ALIGN_VALUE);
2010 return false;
2011 }
2012
2013 return true;
2014 }
2015
2016 /* Check that alignment value FLAG for -falign-NAME is valid at a given
2017 location LOC. OPT_STR points to the stored -falign-NAME=argument and
2018 OPT_FLAG points to the associated -falign-NAME on/off flag. */
2019
2020 static void
2021 check_alignment_argument (location_t loc, const char *flag, const char *name,
2022 int *opt_flag, const char **opt_str)
2023 {
2024 auto_vec<unsigned> align_result;
2025 parse_and_check_align_values (flag, name, align_result, true, loc);
2026
2027 if (align_result.length() >= 1 && align_result[0] == 0)
2028 {
2029 *opt_flag = 1;
2030 *opt_str = NULL;
2031 }
2032 }
2033
2034 /* Print help when OPT__help_ is set. */
2035
2036 void
2037 print_help (struct gcc_options *opts, unsigned int lang_mask,
2038 const char *help_option_argument)
2039 {
2040 const char *a = help_option_argument;
2041 unsigned int include_flags = 0;
2042 /* Note - by default we include undocumented options when listing
2043 specific classes. If you only want to see documented options
2044 then add ",^undocumented" to the --help= option. E.g.:
2045
2046 --help=target,^undocumented */
2047 unsigned int exclude_flags = 0;
2048
2049 if (lang_mask == CL_DRIVER)
2050 return;
2051
2052 /* Walk along the argument string, parsing each word in turn.
2053 The format is:
2054 arg = [^]{word}[,{arg}]
2055 word = {optimizers|target|warnings|undocumented|
2056 params|common|<language>} */
2057 while (*a != 0)
2058 {
2059 static const struct
2060 {
2061 const char *string;
2062 unsigned int flag;
2063 }
2064 specifics[] =
2065 {
2066 { "optimizers", CL_OPTIMIZATION },
2067 { "target", CL_TARGET },
2068 { "warnings", CL_WARNING },
2069 { "undocumented", CL_UNDOCUMENTED },
2070 { "params", CL_PARAMS },
2071 { "joined", CL_JOINED },
2072 { "separate", CL_SEPARATE },
2073 { "common", CL_COMMON },
2074 { NULL, 0 }
2075 };
2076 unsigned int *pflags;
2077 const char *comma;
2078 unsigned int lang_flag, specific_flag;
2079 unsigned int len;
2080 unsigned int i;
2081
2082 if (*a == '^')
2083 {
2084 ++a;
2085 if (*a == '\0')
2086 {
2087 error ("missing argument to %qs", "--help=^");
2088 break;
2089 }
2090 pflags = &exclude_flags;
2091 }
2092 else
2093 pflags = &include_flags;
2094
2095 comma = strchr (a, ',');
2096 if (comma == NULL)
2097 len = strlen (a);
2098 else
2099 len = comma - a;
2100 if (len == 0)
2101 {
2102 a = comma + 1;
2103 continue;
2104 }
2105
2106 /* Check to see if the string matches an option class name. */
2107 for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
2108 if (strncasecmp (a, specifics[i].string, len) == 0)
2109 {
2110 specific_flag = specifics[i].flag;
2111 break;
2112 }
2113
2114 /* Check to see if the string matches a language name.
2115 Note - we rely upon the alpha-sorted nature of the entries in
2116 the lang_names array, specifically that shorter names appear
2117 before their longer variants. (i.e. C before C++). That way
2118 when we are attempting to match --help=c for example we will
2119 match with C first and not C++. */
2120 for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
2121 if (strncasecmp (a, lang_names[i], len) == 0)
2122 {
2123 lang_flag = 1U << i;
2124 break;
2125 }
2126
2127 if (specific_flag != 0)
2128 {
2129 if (lang_flag == 0)
2130 *pflags |= specific_flag;
2131 else
2132 {
2133 /* The option's argument matches both the start of a
2134 language name and the start of an option class name.
2135 We have a special case for when the user has
2136 specified "--help=c", but otherwise we have to issue
2137 a warning. */
2138 if (strncasecmp (a, "c", len) == 0)
2139 *pflags |= lang_flag;
2140 else
2141 warning (0,
2142 "%<--help%> argument %q.*s is ambiguous, "
2143 "please be more specific",
2144 len, a);
2145 }
2146 }
2147 else if (lang_flag != 0)
2148 *pflags |= lang_flag;
2149 else
2150 warning (0,
2151 "unrecognized argument to %<--help=%> option: %q.*s",
2152 len, a);
2153
2154 if (comma == NULL)
2155 break;
2156 a = comma + 1;
2157 }
2158
2159 /* We started using PerFunction/Optimization for parameters and
2160 a warning. We should exclude these from optimization options. */
2161 if (include_flags & CL_OPTIMIZATION)
2162 exclude_flags |= CL_WARNING;
2163 if (!(include_flags & CL_PARAMS))
2164 exclude_flags |= CL_PARAMS;
2165
2166 if (include_flags)
2167 print_specific_help (include_flags, exclude_flags, 0, opts,
2168 lang_mask);
2169 }
2170
2171 /* Handle target- and language-independent options. Return zero to
2172 generate an "unknown option" message. Only options that need
2173 extra handling need to be listed here; if you simply want
2174 DECODED->value assigned to a variable, it happens automatically. */
2175
2176 bool
2177 common_handle_option (struct gcc_options *opts,
2178 struct gcc_options *opts_set,
2179 const struct cl_decoded_option *decoded,
2180 unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
2181 location_t loc,
2182 const struct cl_option_handlers *handlers,
2183 diagnostic_context *dc,
2184 void (*target_option_override_hook) (void))
2185 {
2186 size_t scode = decoded->opt_index;
2187 const char *arg = decoded->arg;
2188 HOST_WIDE_INT value = decoded->value;
2189 enum opt_code code = (enum opt_code) scode;
2190
2191 gcc_assert (decoded->canonical_option_num_elements <= 2);
2192
2193 switch (code)
2194 {
2195 case OPT__help:
2196 {
2197 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
2198 unsigned int undoc_mask;
2199 unsigned int i;
2200
2201 if (lang_mask == CL_DRIVER)
2202 break;
2203
2204 undoc_mask = ((opts->x_verbose_flag | opts->x_extra_warnings)
2205 ? 0
2206 : CL_UNDOCUMENTED);
2207 target_option_override_hook ();
2208 /* First display any single language specific options. */
2209 for (i = 0; i < cl_lang_count; i++)
2210 print_specific_help
2211 (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0, opts,
2212 lang_mask);
2213 /* Next display any multi language specific options. */
2214 print_specific_help (0, undoc_mask, all_langs_mask, opts, lang_mask);
2215 /* Then display any remaining, non-language options. */
2216 for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
2217 if (i != CL_DRIVER)
2218 print_specific_help (i, undoc_mask, 0, opts, lang_mask);
2219 opts->x_exit_after_options = true;
2220 break;
2221 }
2222
2223 case OPT__target_help:
2224 if (lang_mask == CL_DRIVER)
2225 break;
2226
2227 target_option_override_hook ();
2228 print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0, opts, lang_mask);
2229 opts->x_exit_after_options = true;
2230 break;
2231
2232 case OPT__help_:
2233 {
2234 help_option_arguments.safe_push (arg);
2235 opts->x_exit_after_options = true;
2236 break;
2237 }
2238
2239 case OPT__version:
2240 if (lang_mask == CL_DRIVER)
2241 break;
2242
2243 opts->x_exit_after_options = true;
2244 break;
2245
2246 case OPT__completion_:
2247 break;
2248
2249 case OPT_fsanitize_:
2250 opts->x_flag_sanitize
2251 = parse_sanitizer_options (arg, loc, code,
2252 opts->x_flag_sanitize, value, true);
2253
2254 /* Kernel ASan implies normal ASan but does not yet support
2255 all features. */
2256 if (opts->x_flag_sanitize & SANITIZE_KERNEL_ADDRESS)
2257 {
2258 SET_OPTION_IF_UNSET (opts, opts_set,
2259 param_asan_instrumentation_with_call_threshold,
2260 0);
2261 SET_OPTION_IF_UNSET (opts, opts_set, param_asan_globals, 0);
2262 SET_OPTION_IF_UNSET (opts, opts_set, param_asan_stack, 0);
2263 SET_OPTION_IF_UNSET (opts, opts_set, param_asan_protect_allocas, 0);
2264 SET_OPTION_IF_UNSET (opts, opts_set, param_asan_use_after_return, 0);
2265 }
2266 break;
2267
2268 case OPT_fsanitize_recover_:
2269 opts->x_flag_sanitize_recover
2270 = parse_sanitizer_options (arg, loc, code,
2271 opts->x_flag_sanitize_recover, value, true);
2272 break;
2273
2274 case OPT_fasan_shadow_offset_:
2275 /* Deferred. */
2276 break;
2277
2278 case OPT_fsanitize_address_use_after_scope:
2279 opts->x_flag_sanitize_address_use_after_scope = value;
2280 break;
2281
2282 case OPT_fsanitize_recover:
2283 if (value)
2284 opts->x_flag_sanitize_recover
2285 |= (SANITIZE_UNDEFINED | SANITIZE_UNDEFINED_NONDEFAULT)
2286 & ~(SANITIZE_UNREACHABLE | SANITIZE_RETURN);
2287 else
2288 opts->x_flag_sanitize_recover
2289 &= ~(SANITIZE_UNDEFINED | SANITIZE_UNDEFINED_NONDEFAULT);
2290 break;
2291
2292 case OPT_fsanitize_coverage_:
2293 opts->x_flag_sanitize_coverage
2294 = parse_sanitizer_options (arg, loc, code,
2295 opts->x_flag_sanitize_coverage, value, true);
2296 break;
2297
2298 case OPT_O:
2299 case OPT_Os:
2300 case OPT_Ofast:
2301 case OPT_Og:
2302 /* Currently handled in a prescan. */
2303 break;
2304
2305 case OPT_Werror:
2306 dc->warning_as_error_requested = value;
2307 break;
2308
2309 case OPT_Werror_:
2310 if (lang_mask == CL_DRIVER)
2311 break;
2312
2313 enable_warning_as_error (arg, value, lang_mask, handlers,
2314 opts, opts_set, loc, dc);
2315 break;
2316
2317 case OPT_Wfatal_errors:
2318 dc->fatal_errors = value;
2319 break;
2320
2321 case OPT_Wstack_usage_:
2322 opts->x_flag_stack_usage_info = value != -1;
2323 break;
2324
2325 case OPT_Wstrict_aliasing:
2326 set_Wstrict_aliasing (opts, value);
2327 break;
2328
2329 case OPT_Wstrict_overflow:
2330 opts->x_warn_strict_overflow = (value
2331 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2332 : 0);
2333 break;
2334
2335 case OPT_Wsystem_headers:
2336 dc->dc_warn_system_headers = value;
2337 break;
2338
2339 case OPT_aux_info:
2340 opts->x_flag_gen_aux_info = 1;
2341 break;
2342
2343 case OPT_d:
2344 decode_d_option (arg, opts, loc, dc);
2345 break;
2346
2347 case OPT_fcall_used_:
2348 case OPT_fcall_saved_:
2349 /* Deferred. */
2350 break;
2351
2352 case OPT_fdbg_cnt_:
2353 /* Deferred. */
2354 break;
2355
2356 case OPT_fdbg_cnt_list:
2357 /* Deferred. */
2358 opts->x_exit_after_options = true;
2359 break;
2360
2361 case OPT_fdebug_prefix_map_:
2362 case OPT_ffile_prefix_map_:
2363 /* Deferred. */
2364 break;
2365
2366 case OPT_fcallgraph_info:
2367 opts->x_flag_callgraph_info = CALLGRAPH_INFO_NAKED;
2368 break;
2369
2370 case OPT_fcallgraph_info_:
2371 {
2372 char *my_arg, *p;
2373 my_arg = xstrdup (arg);
2374 p = strtok (my_arg, ",");
2375 while (p)
2376 {
2377 if (strcmp (p, "su") == 0)
2378 {
2379 opts->x_flag_callgraph_info |= CALLGRAPH_INFO_STACK_USAGE;
2380 opts->x_flag_stack_usage_info = true;
2381 }
2382 else if (strcmp (p, "da") == 0)
2383 opts->x_flag_callgraph_info |= CALLGRAPH_INFO_DYNAMIC_ALLOC;
2384 else
2385 return 0;
2386 p = strtok (NULL, ",");
2387 }
2388 free (my_arg);
2389 }
2390 break;
2391
2392 case OPT_fdiagnostics_show_location_:
2393 diagnostic_prefixing_rule (dc) = (diagnostic_prefixing_rule_t) value;
2394 break;
2395
2396 case OPT_fdiagnostics_show_caret:
2397 dc->show_caret = value;
2398 break;
2399
2400 case OPT_fdiagnostics_show_labels:
2401 dc->show_labels_p = value;
2402 break;
2403
2404 case OPT_fdiagnostics_show_line_numbers:
2405 dc->show_line_numbers_p = value;
2406 break;
2407
2408 case OPT_fdiagnostics_color_:
2409 diagnostic_color_init (dc, value);
2410 break;
2411
2412 case OPT_fdiagnostics_urls_:
2413 diagnostic_urls_init (dc, value);
2414 break;
2415
2416 case OPT_fdiagnostics_format_:
2417 diagnostic_output_format_init (dc,
2418 (enum diagnostics_output_format)value);
2419 break;
2420
2421 case OPT_fdiagnostics_parseable_fixits:
2422 dc->parseable_fixits_p = value;
2423 break;
2424
2425 case OPT_fdiagnostics_column_unit_:
2426 dc->column_unit = (enum diagnostics_column_unit)value;
2427 break;
2428
2429 case OPT_fdiagnostics_column_origin_:
2430 dc->column_origin = value;
2431 break;
2432
2433 case OPT_fdiagnostics_show_cwe:
2434 dc->show_cwe = value;
2435 break;
2436
2437 case OPT_fdiagnostics_path_format_:
2438 dc->path_format = (enum diagnostic_path_format)value;
2439 break;
2440
2441 case OPT_fdiagnostics_show_path_depths:
2442 dc->show_path_depths = value;
2443 break;
2444
2445 case OPT_fdiagnostics_show_option:
2446 dc->show_option_requested = value;
2447 break;
2448
2449 case OPT_fdiagnostics_minimum_margin_width_:
2450 dc->min_margin_width = value;
2451 break;
2452
2453 case OPT_fdump_:
2454 /* Deferred. */
2455 break;
2456
2457 case OPT_ffast_math:
2458 set_fast_math_flags (opts, value);
2459 break;
2460
2461 case OPT_funsafe_math_optimizations:
2462 set_unsafe_math_optimizations_flags (opts, value);
2463 break;
2464
2465 case OPT_ffixed_:
2466 /* Deferred. */
2467 break;
2468
2469 case OPT_finline_limit_:
2470 SET_OPTION_IF_UNSET (opts, opts_set, param_max_inline_insns_single,
2471 value / 2);
2472 SET_OPTION_IF_UNSET (opts, opts_set, param_max_inline_insns_auto,
2473 value / 2);
2474 break;
2475
2476 case OPT_finstrument_functions_exclude_function_list_:
2477 add_comma_separated_to_vector
2478 (&opts->x_flag_instrument_functions_exclude_functions, arg);
2479 break;
2480
2481 case OPT_finstrument_functions_exclude_file_list_:
2482 add_comma_separated_to_vector
2483 (&opts->x_flag_instrument_functions_exclude_files, arg);
2484 break;
2485
2486 case OPT_fmessage_length_:
2487 pp_set_line_maximum_length (dc->printer, value);
2488 diagnostic_set_caret_max_width (dc, value);
2489 break;
2490
2491 case OPT_fopt_info:
2492 case OPT_fopt_info_:
2493 /* Deferred. */
2494 break;
2495
2496 case OPT_foffload_:
2497 /* Deferred. */
2498 break;
2499
2500 #ifndef ACCEL_COMPILER
2501 case OPT_foffload_abi_:
2502 error_at (loc, "%<-foffload-abi%> option can be specified only for "
2503 "offload compiler");
2504 break;
2505 #endif
2506
2507 case OPT_fpack_struct_:
2508 if (value <= 0 || (value & (value - 1)) || value > 16)
2509 error_at (loc,
2510 "structure alignment must be a small power of two, not %wu",
2511 value);
2512 else
2513 opts->x_initial_max_fld_align = value;
2514 break;
2515
2516 case OPT_fplugin_:
2517 case OPT_fplugin_arg_:
2518 /* Deferred. */
2519 break;
2520
2521 case OPT_fprofile_use_:
2522 opts->x_profile_data_prefix = xstrdup (arg);
2523 opts->x_flag_profile_use = true;
2524 value = true;
2525 /* No break here - do -fprofile-use processing. */
2526 /* FALLTHRU */
2527 case OPT_fprofile_use:
2528 enable_fdo_optimizations (opts, opts_set, value);
2529 SET_OPTION_IF_UNSET (opts, opts_set, flag_profile_reorder_functions,
2530 value);
2531 /* Indirect call profiling should do all useful transformations
2532 speculative devirtualization does. */
2533 if (opts->x_flag_value_profile_transformations)
2534 SET_OPTION_IF_UNSET (opts, opts_set, flag_devirtualize_speculatively,
2535 false);
2536 break;
2537
2538 case OPT_fauto_profile_:
2539 opts->x_auto_profile_file = xstrdup (arg);
2540 opts->x_flag_auto_profile = true;
2541 value = true;
2542 /* No break here - do -fauto-profile processing. */
2543 /* FALLTHRU */
2544 case OPT_fauto_profile:
2545 enable_fdo_optimizations (opts, opts_set, value);
2546 SET_OPTION_IF_UNSET (opts, opts_set, flag_profile_correction, value);
2547 SET_OPTION_IF_UNSET (opts, opts_set,
2548 param_early_inliner_max_iterations, 10);
2549 break;
2550
2551 case OPT_fprofile_generate_:
2552 opts->x_profile_data_prefix = xstrdup (arg);
2553 value = true;
2554 /* No break here - do -fprofile-generate processing. */
2555 /* FALLTHRU */
2556 case OPT_fprofile_generate:
2557 SET_OPTION_IF_UNSET (opts, opts_set, profile_arc_flag, value);
2558 SET_OPTION_IF_UNSET (opts, opts_set, flag_profile_values, value);
2559 SET_OPTION_IF_UNSET (opts, opts_set, flag_inline_functions, value);
2560 SET_OPTION_IF_UNSET (opts, opts_set, flag_ipa_bit_cp, value);
2561 break;
2562
2563 case OPT_fpatchable_function_entry_:
2564 {
2565 char *patch_area_arg = xstrdup (arg);
2566 char *comma = strchr (patch_area_arg, ',');
2567 if (comma)
2568 {
2569 *comma = '\0';
2570 function_entry_patch_area_size =
2571 integral_argument (patch_area_arg);
2572 function_entry_patch_area_start =
2573 integral_argument (comma + 1);
2574 }
2575 else
2576 {
2577 function_entry_patch_area_size =
2578 integral_argument (patch_area_arg);
2579 function_entry_patch_area_start = 0;
2580 }
2581 if (function_entry_patch_area_size < 0
2582 || function_entry_patch_area_size > USHRT_MAX
2583 || function_entry_patch_area_start < 0
2584 || function_entry_patch_area_start > USHRT_MAX
2585 || function_entry_patch_area_size
2586 < function_entry_patch_area_start)
2587 error ("invalid arguments for %<-fpatchable-function-entry%>");
2588 free (patch_area_arg);
2589 }
2590 break;
2591
2592 case OPT_ftree_vectorize:
2593 /* Automatically sets -ftree-loop-vectorize and
2594 -ftree-slp-vectorize. Nothing more to do here. */
2595 break;
2596 case OPT_fshow_column:
2597 dc->show_column = value;
2598 break;
2599
2600 case OPT_frandom_seed:
2601 /* The real switch is -fno-random-seed. */
2602 if (value)
2603 return false;
2604 /* Deferred. */
2605 break;
2606
2607 case OPT_frandom_seed_:
2608 /* Deferred. */
2609 break;
2610
2611 case OPT_fsched_verbose_:
2612 #ifdef INSN_SCHEDULING
2613 /* Handled with Var in common.opt. */
2614 break;
2615 #else
2616 return false;
2617 #endif
2618
2619 case OPT_fsched_stalled_insns_:
2620 opts->x_flag_sched_stalled_insns = value;
2621 if (opts->x_flag_sched_stalled_insns == 0)
2622 opts->x_flag_sched_stalled_insns = -1;
2623 break;
2624
2625 case OPT_fsched_stalled_insns_dep_:
2626 opts->x_flag_sched_stalled_insns_dep = value;
2627 break;
2628
2629 case OPT_fstack_check_:
2630 if (!strcmp (arg, "no"))
2631 opts->x_flag_stack_check = NO_STACK_CHECK;
2632 else if (!strcmp (arg, "generic"))
2633 /* This is the old stack checking method. */
2634 opts->x_flag_stack_check = STACK_CHECK_BUILTIN
2635 ? FULL_BUILTIN_STACK_CHECK
2636 : GENERIC_STACK_CHECK;
2637 else if (!strcmp (arg, "specific"))
2638 /* This is the new stack checking method. */
2639 opts->x_flag_stack_check = STACK_CHECK_BUILTIN
2640 ? FULL_BUILTIN_STACK_CHECK
2641 : STACK_CHECK_STATIC_BUILTIN
2642 ? STATIC_BUILTIN_STACK_CHECK
2643 : GENERIC_STACK_CHECK;
2644 else
2645 warning_at (loc, 0, "unknown stack check parameter %qs", arg);
2646 break;
2647
2648 case OPT_fstack_limit:
2649 /* The real switch is -fno-stack-limit. */
2650 if (value)
2651 return false;
2652 /* Deferred. */
2653 break;
2654
2655 case OPT_fstack_limit_register_:
2656 case OPT_fstack_limit_symbol_:
2657 /* Deferred. */
2658 break;
2659
2660 case OPT_fstack_usage:
2661 opts->x_flag_stack_usage = value;
2662 opts->x_flag_stack_usage_info = value != 0;
2663 break;
2664
2665 case OPT_g:
2666 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg, opts, opts_set,
2667 loc);
2668 break;
2669
2670 case OPT_gdwarf:
2671 if (arg && strlen (arg) != 0)
2672 {
2673 error_at (loc, "%<-gdwarf%s%> is ambiguous; "
2674 "use %<-gdwarf-%s%> for DWARF version "
2675 "or %<-gdwarf%> %<-g%s%> for debug level", arg, arg, arg);
2676 break;
2677 }
2678 else
2679 value = opts->x_dwarf_version;
2680
2681 /* FALLTHRU */
2682 case OPT_gdwarf_:
2683 if (value < 2 || value > 5)
2684 error_at (loc, "dwarf version %wu is not supported", value);
2685 else
2686 opts->x_dwarf_version = value;
2687 set_debug_level (DWARF2_DEBUG, false, "", opts, opts_set, loc);
2688 break;
2689
2690 case OPT_ggdb:
2691 set_debug_level (NO_DEBUG, 2, arg, opts, opts_set, loc);
2692 break;
2693
2694 case OPT_gstabs:
2695 case OPT_gstabs_:
2696 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg, opts, opts_set,
2697 loc);
2698 break;
2699
2700 case OPT_gvms:
2701 set_debug_level (VMS_DEBUG, false, arg, opts, opts_set, loc);
2702 break;
2703
2704 case OPT_gxcoff:
2705 case OPT_gxcoff_:
2706 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg, opts, opts_set,
2707 loc);
2708 break;
2709
2710 case OPT_gz:
2711 case OPT_gz_:
2712 /* Handled completely via specs. */
2713 break;
2714
2715 case OPT_pedantic_errors:
2716 dc->pedantic_errors = 1;
2717 control_warning_option (OPT_Wpedantic, DK_ERROR, NULL, value,
2718 loc, lang_mask,
2719 handlers, opts, opts_set,
2720 dc);
2721 break;
2722
2723 case OPT_flto:
2724 opts->x_flag_lto = value ? "" : NULL;
2725 break;
2726
2727 case OPT_flto_:
2728 if (strcmp (arg, "none") != 0
2729 && strcmp (arg, "jobserver") != 0
2730 && strcmp (arg, "auto") != 0
2731 && atoi (arg) == 0)
2732 error_at (loc,
2733 "unrecognized argument to %<-flto=%> option: %qs", arg);
2734 break;
2735
2736 case OPT_w:
2737 dc->dc_inhibit_warnings = true;
2738 break;
2739
2740 case OPT_fmax_errors_:
2741 dc->max_errors = value;
2742 break;
2743
2744 case OPT_fuse_ld_bfd:
2745 case OPT_fuse_ld_gold:
2746 case OPT_fuse_ld_lld:
2747 case OPT_fuse_linker_plugin:
2748 /* No-op. Used by the driver and passed to us because it starts with f.*/
2749 break;
2750
2751 case OPT_fwrapv:
2752 if (value)
2753 opts->x_flag_trapv = 0;
2754 break;
2755
2756 case OPT_ftrapv:
2757 if (value)
2758 opts->x_flag_wrapv = 0;
2759 break;
2760
2761 case OPT_fstrict_overflow:
2762 opts->x_flag_wrapv = !value;
2763 opts->x_flag_wrapv_pointer = !value;
2764 if (!value)
2765 opts->x_flag_trapv = 0;
2766 break;
2767
2768 case OPT_fipa_icf:
2769 opts->x_flag_ipa_icf_functions = value;
2770 opts->x_flag_ipa_icf_variables = value;
2771 break;
2772
2773 case OPT_falign_loops_:
2774 check_alignment_argument (loc, arg, "loops",
2775 &opts->x_flag_align_loops,
2776 &opts->x_str_align_loops);
2777 break;
2778
2779 case OPT_falign_jumps_:
2780 check_alignment_argument (loc, arg, "jumps",
2781 &opts->x_flag_align_jumps,
2782 &opts->x_str_align_jumps);
2783 break;
2784
2785 case OPT_falign_labels_:
2786 check_alignment_argument (loc, arg, "labels",
2787 &opts->x_flag_align_labels,
2788 &opts->x_str_align_labels);
2789 break;
2790
2791 case OPT_falign_functions_:
2792 check_alignment_argument (loc, arg, "functions",
2793 &opts->x_flag_align_functions,
2794 &opts->x_str_align_functions);
2795 break;
2796
2797 case OPT_ftabstop_:
2798 /* It is documented that we silently ignore silly values. */
2799 if (value >= 1 && value <= 100)
2800 dc->tabstop = value;
2801 break;
2802
2803 default:
2804 /* If the flag was handled in a standard way, assume the lack of
2805 processing here is intentional. */
2806 gcc_assert (option_flag_var (scode, opts));
2807 break;
2808 }
2809
2810 common_handle_option_auto (opts, opts_set, decoded, lang_mask, kind,
2811 loc, handlers, dc);
2812 return true;
2813 }
2814
2815 /* Used to set the level of strict aliasing warnings in OPTS,
2816 when no level is specified (i.e., when -Wstrict-aliasing, and not
2817 -Wstrict-aliasing=level was given).
2818 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2819 and 0 otherwise. After calling this function, wstrict_aliasing will be
2820 set to the default value of -Wstrict_aliasing=level, currently 3. */
2821 static void
2822 set_Wstrict_aliasing (struct gcc_options *opts, int onoff)
2823 {
2824 gcc_assert (onoff == 0 || onoff == 1);
2825 if (onoff != 0)
2826 opts->x_warn_strict_aliasing = 3;
2827 else
2828 opts->x_warn_strict_aliasing = 0;
2829 }
2830
2831 /* The following routines are useful in setting all the flags that
2832 -ffast-math and -fno-fast-math imply. */
2833 static void
2834 set_fast_math_flags (struct gcc_options *opts, int set)
2835 {
2836 if (!opts->frontend_set_flag_unsafe_math_optimizations)
2837 {
2838 opts->x_flag_unsafe_math_optimizations = set;
2839 set_unsafe_math_optimizations_flags (opts, set);
2840 }
2841 if (!opts->frontend_set_flag_finite_math_only)
2842 opts->x_flag_finite_math_only = set;
2843 if (!opts->frontend_set_flag_errno_math)
2844 opts->x_flag_errno_math = !set;
2845 if (set)
2846 {
2847 if (opts->frontend_set_flag_excess_precision == EXCESS_PRECISION_DEFAULT)
2848 opts->x_flag_excess_precision
2849 = set ? EXCESS_PRECISION_FAST : EXCESS_PRECISION_DEFAULT;
2850 if (!opts->frontend_set_flag_signaling_nans)
2851 opts->x_flag_signaling_nans = 0;
2852 if (!opts->frontend_set_flag_rounding_math)
2853 opts->x_flag_rounding_math = 0;
2854 if (!opts->frontend_set_flag_cx_limited_range)
2855 opts->x_flag_cx_limited_range = 1;
2856 }
2857 }
2858
2859 /* When -funsafe-math-optimizations is set the following
2860 flags are set as well. */
2861 static void
2862 set_unsafe_math_optimizations_flags (struct gcc_options *opts, int set)
2863 {
2864 if (!opts->frontend_set_flag_trapping_math)
2865 opts->x_flag_trapping_math = !set;
2866 if (!opts->frontend_set_flag_signed_zeros)
2867 opts->x_flag_signed_zeros = !set;
2868 if (!opts->frontend_set_flag_associative_math)
2869 opts->x_flag_associative_math = set;
2870 if (!opts->frontend_set_flag_reciprocal_math)
2871 opts->x_flag_reciprocal_math = set;
2872 }
2873
2874 /* Return true iff flags in OPTS are set as if -ffast-math. */
2875 bool
2876 fast_math_flags_set_p (const struct gcc_options *opts)
2877 {
2878 return (!opts->x_flag_trapping_math
2879 && opts->x_flag_unsafe_math_optimizations
2880 && opts->x_flag_finite_math_only
2881 && !opts->x_flag_signed_zeros
2882 && !opts->x_flag_errno_math
2883 && opts->x_flag_excess_precision == EXCESS_PRECISION_FAST);
2884 }
2885
2886 /* Return true iff flags are set as if -ffast-math but using the flags stored
2887 in the struct cl_optimization structure. */
2888 bool
2889 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2890 {
2891 return (!opt->x_flag_trapping_math
2892 && opt->x_flag_unsafe_math_optimizations
2893 && opt->x_flag_finite_math_only
2894 && !opt->x_flag_signed_zeros
2895 && !opt->x_flag_errno_math);
2896 }
2897
2898 /* Handle a debug output -g switch for options OPTS
2899 (OPTS_SET->x_write_symbols storing whether a debug type was passed
2900 explicitly), location LOC. EXTENDED is true or false to support
2901 extended output (2 is special and means "-ggdb" was given). */
2902 static void
2903 set_debug_level (enum debug_info_type type, int extended, const char *arg,
2904 struct gcc_options *opts, struct gcc_options *opts_set,
2905 location_t loc)
2906 {
2907 opts->x_use_gnu_debug_info_extensions = extended;
2908
2909 if (type == NO_DEBUG)
2910 {
2911 if (opts->x_write_symbols == NO_DEBUG)
2912 {
2913 opts->x_write_symbols = PREFERRED_DEBUGGING_TYPE;
2914
2915 if (extended == 2)
2916 {
2917 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
2918 opts->x_write_symbols = DWARF2_DEBUG;
2919 #elif defined DBX_DEBUGGING_INFO
2920 opts->x_write_symbols = DBX_DEBUG;
2921 #endif
2922 }
2923
2924 if (opts->x_write_symbols == NO_DEBUG)
2925 warning_at (loc, 0, "target system does not support debug output");
2926 }
2927 }
2928 else
2929 {
2930 /* Does it conflict with an already selected type? */
2931 if (opts_set->x_write_symbols != NO_DEBUG
2932 && opts->x_write_symbols != NO_DEBUG
2933 && type != opts->x_write_symbols)
2934 error_at (loc, "debug format %qs conflicts with prior selection",
2935 debug_type_names[type]);
2936 opts->x_write_symbols = type;
2937 opts_set->x_write_symbols = type;
2938 }
2939
2940 /* A debug flag without a level defaults to level 2.
2941 If off or at level 1, set it to level 2, but if already
2942 at level 3, don't lower it. */
2943 if (*arg == '\0')
2944 {
2945 if (opts->x_debug_info_level < DINFO_LEVEL_NORMAL)
2946 opts->x_debug_info_level = DINFO_LEVEL_NORMAL;
2947 }
2948 else
2949 {
2950 int argval = integral_argument (arg);
2951 if (argval == -1)
2952 error_at (loc, "unrecognized debug output level %qs", arg);
2953 else if (argval > 3)
2954 error_at (loc, "debug output level %qs is too high", arg);
2955 else
2956 opts->x_debug_info_level = (enum debug_info_levels) argval;
2957 }
2958 }
2959
2960 /* Arrange to dump core on error for diagnostic context DC. (The
2961 regular error message is still printed first, except in the case of
2962 abort ().) */
2963
2964 static void
2965 setup_core_dumping (diagnostic_context *dc)
2966 {
2967 #ifdef SIGABRT
2968 signal (SIGABRT, SIG_DFL);
2969 #endif
2970 #if defined(HAVE_SETRLIMIT)
2971 {
2972 struct rlimit rlim;
2973 if (getrlimit (RLIMIT_CORE, &rlim) != 0)
2974 fatal_error (input_location, "getting core file size maximum limit: %m");
2975 rlim.rlim_cur = rlim.rlim_max;
2976 if (setrlimit (RLIMIT_CORE, &rlim) != 0)
2977 fatal_error (input_location,
2978 "setting core file size limit to maximum: %m");
2979 }
2980 #endif
2981 diagnostic_abort_on_error (dc);
2982 }
2983
2984 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
2985 diagnostic context DC. */
2986
2987 static void
2988 decode_d_option (const char *arg, struct gcc_options *opts,
2989 location_t loc, diagnostic_context *dc)
2990 {
2991 int c;
2992
2993 while (*arg)
2994 switch (c = *arg++)
2995 {
2996 case 'A':
2997 opts->x_flag_debug_asm = 1;
2998 break;
2999 case 'p':
3000 opts->x_flag_print_asm_name = 1;
3001 break;
3002 case 'P':
3003 opts->x_flag_dump_rtl_in_asm = 1;
3004 opts->x_flag_print_asm_name = 1;
3005 break;
3006 case 'x':
3007 opts->x_rtl_dump_and_exit = 1;
3008 break;
3009 case 'D': /* These are handled by the preprocessor. */
3010 case 'I':
3011 case 'M':
3012 case 'N':
3013 case 'U':
3014 break;
3015 case 'H':
3016 setup_core_dumping (dc);
3017 break;
3018 case 'a':
3019 opts->x_flag_dump_all_passed = true;
3020 break;
3021
3022 default:
3023 warning_at (loc, 0, "unrecognized gcc debugging option: %c", c);
3024 break;
3025 }
3026 }
3027
3028 /* Enable (or disable if VALUE is 0) a warning option ARG (language
3029 mask LANG_MASK, option handlers HANDLERS) as an error for option
3030 structures OPTS and OPTS_SET, diagnostic context DC (possibly
3031 NULL), location LOC. This is used by -Werror=. */
3032
3033 static void
3034 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
3035 const struct cl_option_handlers *handlers,
3036 struct gcc_options *opts,
3037 struct gcc_options *opts_set,
3038 location_t loc, diagnostic_context *dc)
3039 {
3040 char *new_option;
3041 int option_index;
3042
3043 new_option = XNEWVEC (char, strlen (arg) + 2);
3044 new_option[0] = 'W';
3045 strcpy (new_option + 1, arg);
3046 option_index = find_opt (new_option, lang_mask);
3047 if (option_index == OPT_SPECIAL_unknown)
3048 {
3049 option_proposer op;
3050 const char *hint = op.suggest_option (new_option);
3051 if (hint)
3052 error_at (loc, "%<-W%serror=%s%>: no option %<-%s%>;"
3053 " did you mean %<-%s%>?", value ? "" : "no-",
3054 arg, new_option, hint);
3055 else
3056 error_at (loc, "%<-W%serror=%s%>: no option %<-%s%>",
3057 value ? "" : "no-", arg, new_option);
3058 }
3059 else if (!(cl_options[option_index].flags & CL_WARNING))
3060 error_at (loc, "%<-Werror=%s%>: %<-%s%> is not an option that "
3061 "controls warnings", arg, new_option);
3062 else
3063 {
3064 const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
3065 const char *arg = NULL;
3066
3067 if (cl_options[option_index].flags & CL_JOINED)
3068 arg = new_option + cl_options[option_index].opt_len;
3069 control_warning_option (option_index, (int) kind, arg, value,
3070 loc, lang_mask,
3071 handlers, opts, opts_set, dc);
3072 }
3073 free (new_option);
3074 }
3075
3076 /* Return malloced memory for the name of the option OPTION_INDEX
3077 which enabled a diagnostic (context CONTEXT), originally of type
3078 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
3079 as -Werror. */
3080
3081 char *
3082 option_name (diagnostic_context *context, int option_index,
3083 diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
3084 {
3085 if (option_index)
3086 {
3087 /* A warning classified as an error. */
3088 if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
3089 && diag_kind == DK_ERROR)
3090 return concat (cl_options[OPT_Werror_].opt_text,
3091 /* Skip over "-W". */
3092 cl_options[option_index].opt_text + 2,
3093 NULL);
3094 /* A warning with option. */
3095 else
3096 return xstrdup (cl_options[option_index].opt_text);
3097 }
3098 /* A warning without option classified as an error. */
3099 else if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
3100 || diag_kind == DK_WARNING)
3101 && context->warning_as_error_requested)
3102 return xstrdup (cl_options[OPT_Werror].opt_text);
3103 else
3104 return NULL;
3105 }
3106
3107 /* Get the page within the documentation for this option. */
3108
3109 static const char *
3110 get_option_html_page (int option_index)
3111 {
3112 const cl_option *cl_opt = &cl_options[option_index];
3113
3114 /* Analyzer options are on their own page. */
3115 if (strstr(cl_opt->opt_text, "analyzer-"))
3116 return "gcc/Static-Analyzer-Options.html";
3117
3118 #ifdef CL_Fortran
3119 if ((cl_opt->flags & CL_Fortran) != 0
3120 /* If it is option common to both C/C++ and Fortran, it is documented
3121 in gcc/ rather than gfortran/ docs. */
3122 && (cl_opt->flags & CL_C) == 0
3123 #ifdef CL_CXX
3124 && (cl_opt->flags & CL_CXX) == 0
3125 #endif
3126 )
3127 return "gfortran/Error-and-Warning-Options.html";
3128 #endif
3129
3130 return "gcc/Warning-Options.html";
3131 }
3132
3133 /* Return malloced memory for a URL describing the option OPTION_INDEX
3134 which enabled a diagnostic (context CONTEXT). */
3135
3136 char *
3137 get_option_url (diagnostic_context *, int option_index)
3138 {
3139 if (option_index)
3140 return concat (/* DOCUMENTATION_ROOT_URL should be supplied via -D by
3141 the Makefile (see --with-documentation-root-url), and
3142 should have a trailing slash. */
3143 DOCUMENTATION_ROOT_URL,
3144
3145 /* get_option_html_page will return something like
3146 "gcc/Warning-Options.html". */
3147 get_option_html_page (option_index),
3148
3149 /* Expect an anchor of the form "index-Wfoo" e.g.
3150 <a name="index-Wformat"></a>, and thus an id within
3151 the URL of "#index-Wformat". */
3152 "#index", cl_options[option_index].opt_text,
3153 NULL);
3154 else
3155 return NULL;
3156 }
3157
3158 #if CHECKING_P
3159
3160 namespace selftest {
3161
3162 /* Verify that get_option_html_page works as expected. */
3163
3164 static void
3165 test_get_option_html_page ()
3166 {
3167 ASSERT_STREQ (get_option_html_page (OPT_Wcpp), "gcc/Warning-Options.html");
3168 ASSERT_STREQ (get_option_html_page (OPT_Wanalyzer_double_free),
3169 "gcc/Static-Analyzer-Options.html");
3170 #ifdef CL_Fortran
3171 ASSERT_STREQ (get_option_html_page (OPT_Wline_truncation),
3172 "gfortran/Error-and-Warning-Options.html");
3173 #endif
3174 }
3175
3176 /* Run all of the selftests within this file. */
3177
3178 void
3179 opts_c_tests ()
3180 {
3181 test_get_option_html_page ();
3182 }
3183
3184 } // namespace selftest
3185
3186 #endif /* #if CHECKING_P */
Mirror of the offical gcc git repository hosted at gcc.gnu.org