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
set_struct_debug_option(struct gcc_options * opts,location_t loc,const char * spec)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
strip_off_ending(char * name,int len)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
base_of_path(const char * path,const char ** base_out)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
target_handle_option(struct gcc_options * opts,struct gcc_options * opts_set,const struct cl_decoded_option * decoded,unsigned int lang_mask ATTRIBUTE_UNUSED,int kind,location_t loc,const struct cl_option_handlers * handlers ATTRIBUTE_UNUSED,diagnostic_context * dc,void (*)(void))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
add_comma_separated_to_vector(void ** pvec,const char * arg)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
init_opts_obstack(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
init_options_struct(struct gcc_options * opts,struct gcc_options * opts_set)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
maybe_default_option(struct gcc_options * opts,struct gcc_options * opts_set,const struct default_options * default_opt,int level,bool size,bool fast,bool debug,unsigned int lang_mask,const struct cl_option_handlers * handlers,location_t loc,diagnostic_context * dc)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
maybe_default_options(struct gcc_options * opts,struct gcc_options * opts_set,const struct default_options * default_opts,int level,bool size,bool fast,bool debug,unsigned int lang_mask,const struct cl_option_handlers * handlers,location_t loc,diagnostic_context * dc)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
default_options_optimization(struct gcc_options * opts,struct gcc_options * opts_set,struct cl_decoded_option * decoded_options,unsigned int decoded_options_count,location_t loc,unsigned int lang_mask,const struct cl_option_handlers * handlers,diagnostic_context * dc)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
control_options_for_live_patching(struct gcc_options * opts,struct gcc_options * opts_set,enum live_patching_level level,location_t loc)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
finish_options(struct gcc_options * opts,struct gcc_options * opts_set,location_t loc)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 else if (opts->x_aux_base_name
849 && strcmp (opts->x_aux_base_name, HOST_BIT_BUCKET) != 0)
850 /* AUX_BASE_NAME is set and is not the bit bucket. If it
851 contains a directory component, prepend those directories.
852 Typically this places things in the same directory as the
853 object file. */
854 {
855 const char *aux_base;
856
857 base_of_path (opts->x_aux_base_name, &aux_base);
858 if (opts->x_aux_base_name != aux_base)
859 {
860 int dir_len = aux_base - opts->x_aux_base_name;
861 char *new_dump_base_name
862 = XOBNEWVEC (&opts_obstack, char,
863 strlen (opts->x_dump_base_name) + dir_len + 1);
864
865 /* Copy directory component from OPTS->X_AUX_BASE_NAME. */
866 memcpy (new_dump_base_name, opts->x_aux_base_name, dir_len);
867 /* Append existing OPTS->X_DUMP_BASE_NAME. */
868 strcpy (new_dump_base_name + dir_len, opts->x_dump_base_name);
869 opts->x_dump_base_name = new_dump_base_name;
870 }
871 }
872
873 /* It is definitely prefixed now. */
874 opts->x_dump_base_name_prefixed = true;
875 }
876
877 /* Handle related options for unit-at-a-time, toplevel-reorder, and
878 section-anchors. */
879 if (!opts->x_flag_unit_at_a_time)
880 {
881 if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
882 error_at (loc, "section anchors must be disabled when unit-at-a-time "
883 "is disabled");
884 opts->x_flag_section_anchors = 0;
885 if (opts->x_flag_toplevel_reorder == 1)
886 error_at (loc, "toplevel reorder must be disabled when unit-at-a-time "
887 "is disabled");
888 opts->x_flag_toplevel_reorder = 0;
889 }
890
891 /* -fself-test depends on the state of the compiler prior to
892 compiling anything. Ideally it should be run on an empty source
893 file. However, in case we get run with actual source, assume
894 -fsyntax-only which will inhibit any compiler initialization
895 which may confuse the self tests. */
896 if (opts->x_flag_self_test)
897 opts->x_flag_syntax_only = 1;
898
899 if (opts->x_flag_tm && opts->x_flag_non_call_exceptions)
900 sorry ("transactional memory is not supported with non-call exceptions");
901
902 /* Unless the user has asked for section anchors, we disable toplevel
903 reordering at -O0 to disable transformations that might be surprising
904 to end users and to get -fno-toplevel-reorder tested. */
905 if (!opts->x_optimize
906 && opts->x_flag_toplevel_reorder == 2
907 && !(opts->x_flag_section_anchors && opts_set->x_flag_section_anchors))
908 {
909 opts->x_flag_toplevel_reorder = 0;
910 opts->x_flag_section_anchors = 0;
911 }
912 if (!opts->x_flag_toplevel_reorder)
913 {
914 if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
915 error_at (loc, "section anchors must be disabled when toplevel reorder"
916 " is disabled");
917 opts->x_flag_section_anchors = 0;
918 }
919
920 if (!opts->x_flag_opts_finished)
921 {
922 /* We initialize opts->x_flag_pie to -1 so that targets can set a
923 default value. */
924 if (opts->x_flag_pie == -1)
925 {
926 /* We initialize opts->x_flag_pic to -1 so that we can tell if
927 -fpic, -fPIC, -fno-pic or -fno-PIC is used. */
928 if (opts->x_flag_pic == -1)
929 opts->x_flag_pie = DEFAULT_FLAG_PIE;
930 else
931 opts->x_flag_pie = 0;
932 }
933 /* If -fPIE or -fpie is used, turn on PIC. */
934 if (opts->x_flag_pie)
935 opts->x_flag_pic = opts->x_flag_pie;
936 else if (opts->x_flag_pic == -1)
937 opts->x_flag_pic = 0;
938 if (opts->x_flag_pic && !opts->x_flag_pie)
939 opts->x_flag_shlib = 1;
940 opts->x_flag_opts_finished = true;
941 }
942
943 /* We initialize opts->x_flag_stack_protect to -1 so that targets
944 can set a default value. */
945 if (opts->x_flag_stack_protect == -1)
946 opts->x_flag_stack_protect = DEFAULT_FLAG_SSP;
947
948 if (opts->x_optimize == 0)
949 {
950 /* Inlining does not work if not optimizing,
951 so force it not to be done. */
952 opts->x_warn_inline = 0;
953 opts->x_flag_no_inline = 1;
954 }
955
956 /* The optimization to partition hot and cold basic blocks into separate
957 sections of the .o and executable files does not work (currently)
958 with exception handling. This is because there is no support for
959 generating unwind info. If opts->x_flag_exceptions is turned on
960 we need to turn off the partitioning optimization. */
961
962 ui_except = targetm_common.except_unwind_info (opts);
963
964 if (opts->x_flag_exceptions
965 && opts->x_flag_reorder_blocks_and_partition
966 && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))
967 {
968 if (opts_set->x_flag_reorder_blocks_and_partition)
969 inform (loc,
970 "%<-freorder-blocks-and-partition%> does not work "
971 "with exceptions on this architecture");
972 opts->x_flag_reorder_blocks_and_partition = 0;
973 opts->x_flag_reorder_blocks = 1;
974 }
975
976 /* If user requested unwind info, then turn off the partitioning
977 optimization. */
978
979 if (opts->x_flag_unwind_tables
980 && !targetm_common.unwind_tables_default
981 && opts->x_flag_reorder_blocks_and_partition
982 && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))
983 {
984 if (opts_set->x_flag_reorder_blocks_and_partition)
985 inform (loc,
986 "%<-freorder-blocks-and-partition%> does not support "
987 "unwind info on this architecture");
988 opts->x_flag_reorder_blocks_and_partition = 0;
989 opts->x_flag_reorder_blocks = 1;
990 }
991
992 /* If the target requested unwind info, then turn off the partitioning
993 optimization with a different message. Likewise, if the target does not
994 support named sections. */
995
996 if (opts->x_flag_reorder_blocks_and_partition
997 && (!targetm_common.have_named_sections
998 || (opts->x_flag_unwind_tables
999 && targetm_common.unwind_tables_default
1000 && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))))
1001 {
1002 if (opts_set->x_flag_reorder_blocks_and_partition)
1003 inform (loc,
1004 "%<-freorder-blocks-and-partition%> does not work "
1005 "on this architecture");
1006 opts->x_flag_reorder_blocks_and_partition = 0;
1007 opts->x_flag_reorder_blocks = 1;
1008 }
1009
1010
1011 /* Pipelining of outer loops is only possible when general pipelining
1012 capabilities are requested. */
1013 if (!opts->x_flag_sel_sched_pipelining)
1014 opts->x_flag_sel_sched_pipelining_outer_loops = 0;
1015
1016 if (opts->x_flag_conserve_stack)
1017 {
1018 SET_OPTION_IF_UNSET (opts, opts_set, param_large_stack_frame, 100);
1019 SET_OPTION_IF_UNSET (opts, opts_set, param_stack_frame_growth, 40);
1020 }
1021
1022 if (opts->x_flag_lto)
1023 {
1024 #ifdef ENABLE_LTO
1025 opts->x_flag_generate_lto = 1;
1026
1027 /* When generating IL, do not operate in whole-program mode.
1028 Otherwise, symbols will be privatized too early, causing link
1029 errors later. */
1030 opts->x_flag_whole_program = 0;
1031 #else
1032 error_at (loc, "LTO support has not been enabled in this configuration");
1033 #endif
1034 if (!opts->x_flag_fat_lto_objects
1035 && (!HAVE_LTO_PLUGIN
1036 || (opts_set->x_flag_use_linker_plugin
1037 && !opts->x_flag_use_linker_plugin)))
1038 {
1039 if (opts_set->x_flag_fat_lto_objects)
1040 error_at (loc, "%<-fno-fat-lto-objects%> are supported only with "
1041 "linker plugin");
1042 opts->x_flag_fat_lto_objects = 1;
1043 }
1044
1045 /* -gsplit-dwarf isn't compatible with LTO, see PR88389. */
1046 if (opts->x_dwarf_split_debug_info)
1047 {
1048 inform (loc, "%<-gsplit-dwarf%> is not supported with LTO,"
1049 " disabling");
1050 opts->x_dwarf_split_debug_info = 0;
1051 }
1052 }
1053
1054 /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
1055 default value if they choose based on other options. */
1056 if (opts->x_flag_split_stack == -1)
1057 opts->x_flag_split_stack = 0;
1058 else if (opts->x_flag_split_stack)
1059 {
1060 if (!targetm_common.supports_split_stack (true, opts))
1061 {
1062 error_at (loc, "%<-fsplit-stack%> is not supported by "
1063 "this compiler configuration");
1064 opts->x_flag_split_stack = 0;
1065 }
1066 }
1067
1068 /* If stack splitting is turned on, and the user did not explicitly
1069 request function partitioning, turn off partitioning, as it
1070 confuses the linker when trying to handle partitioned split-stack
1071 code that calls a non-split-stack functions. But if partitioning
1072 was turned on explicitly just hope for the best. */
1073 if (opts->x_flag_split_stack
1074 && opts->x_flag_reorder_blocks_and_partition)
1075 SET_OPTION_IF_UNSET (opts, opts_set, flag_reorder_blocks_and_partition, 0);
1076
1077 if (opts->x_flag_reorder_blocks_and_partition)
1078 SET_OPTION_IF_UNSET (opts, opts_set, flag_reorder_functions, 1);
1079
1080 /* The -gsplit-dwarf option requires -ggnu-pubnames. */
1081 if (opts->x_dwarf_split_debug_info)
1082 opts->x_debug_generate_pub_sections = 2;
1083
1084 if ((opts->x_flag_sanitize
1085 & (SANITIZE_USER_ADDRESS | SANITIZE_KERNEL_ADDRESS)) == 0)
1086 {
1087 if (opts->x_flag_sanitize & SANITIZE_POINTER_COMPARE)
1088 error_at (loc,
1089 "%<-fsanitize=pointer-compare%> must be combined with "
1090 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1091 if (opts->x_flag_sanitize & SANITIZE_POINTER_SUBTRACT)
1092 error_at (loc,
1093 "%<-fsanitize=pointer-subtract%> must be combined with "
1094 "%<-fsanitize=address%> or %<-fsanitize=kernel-address%>");
1095 }
1096
1097 /* Userspace and kernel ASan conflict with each other. */
1098 if ((opts->x_flag_sanitize & SANITIZE_USER_ADDRESS)
1099 && (opts->x_flag_sanitize & SANITIZE_KERNEL_ADDRESS))
1100 error_at (loc,
1101 "%<-fsanitize=address%> is incompatible with "
1102 "%<-fsanitize=kernel-address%>");
1103
1104 /* And with TSan. */
1105 if ((opts->x_flag_sanitize & SANITIZE_ADDRESS)
1106 && (opts->x_flag_sanitize & SANITIZE_THREAD))
1107 error_at (loc,
1108 "%<-fsanitize=address%> and %<-fsanitize=kernel-address%> "
1109 "are incompatible with %<-fsanitize=thread%>");
1110
1111 if ((opts->x_flag_sanitize & SANITIZE_LEAK)
1112 && (opts->x_flag_sanitize & SANITIZE_THREAD))
1113 error_at (loc,
1114 "%<-fsanitize=leak%> is incompatible with %<-fsanitize=thread%>");
1115
1116 /* Check error recovery for -fsanitize-recover option. */
1117 for (int i = 0; sanitizer_opts[i].name != NULL; ++i)
1118 if ((opts->x_flag_sanitize_recover & sanitizer_opts[i].flag)
1119 && !sanitizer_opts[i].can_recover)
1120 error_at (loc, "%<-fsanitize-recover=%s%> is not supported",
1121 sanitizer_opts[i].name);
1122
1123 /* When instrumenting the pointers, we don't want to remove
1124 the null pointer checks. */
1125 if (opts->x_flag_sanitize & (SANITIZE_NULL | SANITIZE_NONNULL_ATTRIBUTE
1126 | SANITIZE_RETURNS_NONNULL_ATTRIBUTE))
1127 opts->x_flag_delete_null_pointer_checks = 0;
1128
1129 /* Aggressive compiler optimizations may cause false negatives. */
1130 if (opts->x_flag_sanitize & ~(SANITIZE_LEAK | SANITIZE_UNREACHABLE))
1131 opts->x_flag_aggressive_loop_optimizations = 0;
1132
1133 /* Enable -fsanitize-address-use-after-scope if address sanitizer is
1134 enabled. */
1135 if (opts->x_flag_sanitize & SANITIZE_USER_ADDRESS)
1136 SET_OPTION_IF_UNSET (opts, opts_set, flag_sanitize_address_use_after_scope,
1137 true);
1138
1139 /* Force -fstack-reuse=none in case -fsanitize-address-use-after-scope
1140 is enabled. */
1141 if (opts->x_flag_sanitize_address_use_after_scope)
1142 {
1143 if (opts->x_flag_stack_reuse != SR_NONE
1144 && opts_set->x_flag_stack_reuse != SR_NONE)
1145 error_at (loc,
1146 "%<-fsanitize-address-use-after-scope%> requires "
1147 "%<-fstack-reuse=none%> option");
1148
1149 opts->x_flag_stack_reuse = SR_NONE;
1150 }
1151
1152 if ((opts->x_flag_sanitize & SANITIZE_USER_ADDRESS) && opts->x_flag_tm)
1153 sorry ("transactional memory is not supported with %<-fsanitize=address%>");
1154
1155 if ((opts->x_flag_sanitize & SANITIZE_KERNEL_ADDRESS) && opts->x_flag_tm)
1156 sorry ("transactional memory is not supported with "
1157 "%<-fsanitize=kernel-address%>");
1158
1159 /* Currently live patching is not support for LTO. */
1160 if (opts->x_flag_live_patching && opts->x_flag_lto)
1161 sorry ("live patching is not supported with LTO");
1162
1163 /* Currently vtable verification is not supported for LTO */
1164 if (opts->x_flag_vtable_verify && opts->x_flag_lto)
1165 sorry ("vtable verification is not supported with LTO");
1166
1167 /* Control IPA optimizations based on different -flive-patching level. */
1168 if (opts->x_flag_live_patching)
1169 control_options_for_live_patching (opts, opts_set,
1170 opts->x_flag_live_patching,
1171 loc);
1172
1173 /* Unrolling all loops implies that standard loop unrolling must also
1174 be done. */
1175 if (opts->x_flag_unroll_all_loops)
1176 opts->x_flag_unroll_loops = 1;
1177
1178 /* Allow cunroll to grow size accordingly. */
1179 if (!opts_set->x_flag_cunroll_grow_size)
1180 opts->x_flag_cunroll_grow_size
1181 = (opts->x_flag_unroll_loops
1182 || opts->x_flag_peel_loops
1183 || opts->x_optimize >= 3);
1184 }
1185
1186 #define LEFT_COLUMN 27
1187
1188 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1189 followed by word-wrapped HELP in a second column. */
1190 static void
wrap_help(const char * help,const char * item,unsigned int item_width,unsigned int columns)1191 wrap_help (const char *help,
1192 const char *item,
1193 unsigned int item_width,
1194 unsigned int columns)
1195 {
1196 unsigned int col_width = LEFT_COLUMN;
1197 unsigned int remaining, room, len;
1198
1199 remaining = strlen (help);
1200
1201 do
1202 {
1203 room = columns - 3 - MAX (col_width, item_width);
1204 if (room > columns)
1205 room = 0;
1206 len = remaining;
1207
1208 if (room < len)
1209 {
1210 unsigned int i;
1211
1212 for (i = 0; help[i]; i++)
1213 {
1214 if (i >= room && len != remaining)
1215 break;
1216 if (help[i] == ' ')
1217 len = i;
1218 else if ((help[i] == '-' || help[i] == '/')
1219 && help[i + 1] != ' '
1220 && i > 0 && ISALPHA (help[i - 1]))
1221 len = i + 1;
1222 }
1223 }
1224
1225 printf (" %-*.*s %.*s\n", col_width, item_width, item, len, help);
1226 item_width = 0;
1227 while (help[len] == ' ')
1228 len++;
1229 help += len;
1230 remaining -= len;
1231 }
1232 while (remaining);
1233 }
1234
1235 /* Data structure used to print list of valid option values. */
1236
1237 class option_help_tuple
1238 {
1239 public:
option_help_tuple(int code,vec<const char * > values)1240 option_help_tuple (int code, vec<const char *> values):
1241 m_code (code), m_values (values)
1242 {}
1243
1244 /* Code of an option. */
1245 int m_code;
1246
1247 /* List of possible values. */
1248 vec<const char *> m_values;
1249 };
1250
1251 /* Print help for a specific front-end, etc. */
1252 static void
print_filtered_help(unsigned int include_flags,unsigned int exclude_flags,unsigned int any_flags,unsigned int columns,struct gcc_options * opts,unsigned int lang_mask)1253 print_filtered_help (unsigned int include_flags,
1254 unsigned int exclude_flags,
1255 unsigned int any_flags,
1256 unsigned int columns,
1257 struct gcc_options *opts,
1258 unsigned int lang_mask)
1259 {
1260 unsigned int i;
1261 const char *help;
1262 bool found = false;
1263 bool displayed = false;
1264 char new_help[256];
1265
1266 if (!opts->x_help_printed)
1267 opts->x_help_printed = XCNEWVAR (char, cl_options_count);
1268
1269 if (!opts->x_help_enum_printed)
1270 opts->x_help_enum_printed = XCNEWVAR (char, cl_enums_count);
1271
1272 auto_vec<option_help_tuple> help_tuples;
1273
1274 for (i = 0; i < cl_options_count; i++)
1275 {
1276 const struct cl_option *option = cl_options + i;
1277 unsigned int len;
1278 const char *opt;
1279 const char *tab;
1280
1281 if (include_flags == 0
1282 || ((option->flags & include_flags) != include_flags))
1283 {
1284 if ((option->flags & any_flags) == 0)
1285 continue;
1286 }
1287
1288 /* Skip unwanted switches. */
1289 if ((option->flags & exclude_flags) != 0)
1290 continue;
1291
1292 /* The driver currently prints its own help text. */
1293 if ((option->flags & CL_DRIVER) != 0
1294 && (option->flags & (((1U << cl_lang_count) - 1)
1295 | CL_COMMON | CL_TARGET)) == 0)
1296 continue;
1297
1298 /* If an option contains a language specification,
1299 exclude it from common unless all languages are present. */
1300 if ((include_flags & CL_COMMON)
1301 && !(option->flags & CL_DRIVER)
1302 && (option->flags & CL_LANG_ALL)
1303 && (option->flags & CL_LANG_ALL) != CL_LANG_ALL)
1304 continue;
1305
1306 found = true;
1307 /* Skip switches that have already been printed. */
1308 if (opts->x_help_printed[i])
1309 continue;
1310
1311 opts->x_help_printed[i] = true;
1312
1313 help = option->help;
1314 if (help == NULL)
1315 {
1316 if (exclude_flags & CL_UNDOCUMENTED)
1317 continue;
1318
1319 help = undocumented_msg;
1320 }
1321
1322 /* Get the translation. */
1323 help = _(help);
1324
1325 if (option->alias_target < N_OPTS
1326 && cl_options [option->alias_target].help)
1327 {
1328 const struct cl_option *target = cl_options + option->alias_target;
1329 if (option->help == NULL)
1330 {
1331 /* The option is undocumented but is an alias for an option that
1332 is documented. If the option has alias arguments, then its
1333 purpose is to provide certain arguments to the other option, so
1334 inform the reader of this. Otherwise, point the reader to the
1335 other option in preference to the former. */
1336
1337 if (option->alias_arg)
1338 {
1339 if (option->neg_alias_arg)
1340 snprintf (new_help, sizeof new_help,
1341 _("Same as %s%s (or, in negated form, %s%s)."),
1342 target->opt_text, option->alias_arg,
1343 target->opt_text, option->neg_alias_arg);
1344 else
1345 snprintf (new_help, sizeof new_help,
1346 _("Same as %s%s."),
1347 target->opt_text, option->alias_arg);
1348 }
1349 else
1350 snprintf (new_help, sizeof new_help,
1351 _("Same as %s."),
1352 target->opt_text);
1353 }
1354 else
1355 {
1356 /* For documented options with aliases, mention the aliased
1357 option's name for reference. */
1358 snprintf (new_help, sizeof new_help,
1359 _("%s Same as %s."),
1360 help, cl_options [option->alias_target].opt_text);
1361 }
1362
1363 help = new_help;
1364 }
1365
1366 if (option->warn_message)
1367 {
1368 /* Mention that the use of the option will trigger a warning. */
1369 if (help == new_help)
1370 snprintf (new_help + strlen (new_help),
1371 sizeof new_help - strlen (new_help),
1372 " %s", _(use_diagnosed_msg));
1373 else
1374 snprintf (new_help, sizeof new_help,
1375 "%s %s", help, _(use_diagnosed_msg));
1376
1377 help = new_help;
1378 }
1379
1380 /* Find the gap between the name of the
1381 option and its descriptive text. */
1382 tab = strchr (help, '\t');
1383 if (tab)
1384 {
1385 len = tab - help;
1386 opt = help;
1387 help = tab + 1;
1388 }
1389 else
1390 {
1391 opt = option->opt_text;
1392 len = strlen (opt);
1393 }
1394
1395 /* With the -Q option enabled we change the descriptive text associated
1396 with an option to be an indication of its current setting. */
1397 if (!opts->x_quiet_flag)
1398 {
1399 void *flag_var = option_flag_var (i, opts);
1400
1401 if (len < (LEFT_COLUMN + 2))
1402 strcpy (new_help, "\t\t");
1403 else
1404 strcpy (new_help, "\t");
1405
1406 /* Set to print whether the option is enabled or disabled,
1407 or, if it's an alias for another option, the name of
1408 the aliased option. */
1409 bool print_state = false;
1410
1411 if (flag_var != NULL
1412 && option->var_type != CLVC_DEFER)
1413 {
1414 /* If OPTION is only available for a specific subset
1415 of languages other than this one, mention them. */
1416 bool avail_for_lang = true;
1417 if (unsigned langset = option->flags & CL_LANG_ALL)
1418 {
1419 if (!(langset & lang_mask))
1420 {
1421 avail_for_lang = false;
1422 strcat (new_help, _("[available in "));
1423 for (unsigned i = 0, n = 0; (1U << i) < CL_LANG_ALL; ++i)
1424 if (langset & (1U << i))
1425 {
1426 if (n++)
1427 strcat (new_help, ", ");
1428 strcat (new_help, lang_names[i]);
1429 }
1430 strcat (new_help, "]");
1431 }
1432 }
1433 if (!avail_for_lang)
1434 ; /* Print nothing else if the option is not available
1435 in the current language. */
1436 else if (option->flags & CL_JOINED)
1437 {
1438 if (option->var_type == CLVC_STRING)
1439 {
1440 if (* (const char **) flag_var != NULL)
1441 snprintf (new_help + strlen (new_help),
1442 sizeof (new_help) - strlen (new_help),
1443 "%s", * (const char **) flag_var);
1444 }
1445 else if (option->var_type == CLVC_ENUM)
1446 {
1447 const struct cl_enum *e = &cl_enums[option->var_enum];
1448 int value;
1449 const char *arg = NULL;
1450
1451 value = e->get (flag_var);
1452 enum_value_to_arg (e->values, &arg, value, lang_mask);
1453 if (arg == NULL)
1454 arg = _("[default]");
1455 snprintf (new_help + strlen (new_help),
1456 sizeof (new_help) - strlen (new_help),
1457 "%s", arg);
1458 }
1459 else
1460 {
1461 if (option->cl_host_wide_int)
1462 sprintf (new_help + strlen (new_help),
1463 _("%llu bytes"), (unsigned long long)
1464 *(unsigned HOST_WIDE_INT *) flag_var);
1465 else
1466 sprintf (new_help + strlen (new_help),
1467 "%i", * (int *) flag_var);
1468 }
1469 }
1470 else
1471 print_state = true;
1472 }
1473 else
1474 /* When there is no argument, print the option state only
1475 if the option takes no argument. */
1476 print_state = !(option->flags & CL_JOINED);
1477
1478 if (print_state)
1479 {
1480 if (option->alias_target < N_OPTS
1481 && option->alias_target != OPT_SPECIAL_warn_removed
1482 && option->alias_target != OPT_SPECIAL_ignore
1483 && option->alias_target != OPT_SPECIAL_input_file
1484 && option->alias_target != OPT_SPECIAL_program_name
1485 && option->alias_target != OPT_SPECIAL_unknown)
1486 {
1487 const struct cl_option *target
1488 = &cl_options[option->alias_target];
1489 sprintf (new_help + strlen (new_help), "%s%s",
1490 target->opt_text,
1491 option->alias_arg ? option->alias_arg : "");
1492 }
1493 else if (option->alias_target == OPT_SPECIAL_ignore)
1494 strcat (new_help, ("[ignored]"));
1495 else
1496 {
1497 /* Print the state for an on/off option. */
1498 int ena = option_enabled (i, lang_mask, opts);
1499 if (ena > 0)
1500 strcat (new_help, _("[enabled]"));
1501 else if (ena == 0)
1502 strcat (new_help, _("[disabled]"));
1503 }
1504 }
1505
1506 help = new_help;
1507 }
1508
1509 if (option->range_max != -1)
1510 {
1511 char b[128];
1512 snprintf (b, sizeof (b), "<%d,%d>", option->range_min,
1513 option->range_max);
1514 opt = concat (opt, b, NULL);
1515 len += strlen (b);
1516 }
1517
1518 wrap_help (help, opt, len, columns);
1519 displayed = true;
1520
1521 if (option->var_type == CLVC_ENUM
1522 && opts->x_help_enum_printed[option->var_enum] != 2)
1523 opts->x_help_enum_printed[option->var_enum] = 1;
1524 else
1525 {
1526 vec<const char *> option_values
1527 = targetm_common.get_valid_option_values (i, NULL);
1528 if (!option_values.is_empty ())
1529 help_tuples.safe_push (option_help_tuple (i, option_values));
1530 }
1531 }
1532
1533 if (! found)
1534 {
1535 unsigned int langs = include_flags & CL_LANG_ALL;
1536
1537 if (langs == 0)
1538 printf (_(" No options with the desired characteristics were found\n"));
1539 else
1540 {
1541 unsigned int i;
1542
1543 /* PR 31349: Tell the user how to see all of the
1544 options supported by a specific front end. */
1545 for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1546 if ((1U << i) & langs)
1547 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end.\n"),
1548 lang_names[i], lang_names[i]);
1549 }
1550
1551 }
1552 else if (! displayed)
1553 printf (_(" All options with the desired characteristics have already been displayed\n"));
1554
1555 putchar ('\n');
1556
1557 /* Print details of enumerated option arguments, if those
1558 enumerations have help text headings provided. If no help text
1559 is provided, presume that the possible values are listed in the
1560 help text for the relevant options. */
1561 for (i = 0; i < cl_enums_count; i++)
1562 {
1563 unsigned int j, pos;
1564
1565 if (opts->x_help_enum_printed[i] != 1)
1566 continue;
1567 if (cl_enums[i].help == NULL)
1568 continue;
1569 printf (" %s\n ", _(cl_enums[i].help));
1570 pos = 4;
1571 for (j = 0; cl_enums[i].values[j].arg != NULL; j++)
1572 {
1573 unsigned int len = strlen (cl_enums[i].values[j].arg);
1574
1575 if (pos > 4 && pos + 1 + len <= columns)
1576 {
1577 printf (" %s", cl_enums[i].values[j].arg);
1578 pos += 1 + len;
1579 }
1580 else
1581 {
1582 if (pos > 4)
1583 {
1584 printf ("\n ");
1585 pos = 4;
1586 }
1587 printf ("%s", cl_enums[i].values[j].arg);
1588 pos += len;
1589 }
1590 }
1591 printf ("\n\n");
1592 opts->x_help_enum_printed[i] = 2;
1593 }
1594
1595 for (unsigned i = 0; i < help_tuples.length (); i++)
1596 {
1597 const struct cl_option *option = cl_options + help_tuples[i].m_code;
1598 printf (_(" Known valid arguments for %s option:\n "),
1599 option->opt_text);
1600 for (unsigned j = 0; j < help_tuples[i].m_values.length (); j++)
1601 printf (" %s", help_tuples[i].m_values[j]);
1602 printf ("\n\n");
1603 }
1604 }
1605
1606 /* Display help for a specified type of option.
1607 The options must have ALL of the INCLUDE_FLAGS set
1608 ANY of the flags in the ANY_FLAGS set
1609 and NONE of the EXCLUDE_FLAGS set. The current option state is in
1610 OPTS; LANG_MASK is used for interpreting enumerated option state. */
1611 static void
print_specific_help(unsigned int include_flags,unsigned int exclude_flags,unsigned int any_flags,struct gcc_options * opts,unsigned int lang_mask)1612 print_specific_help (unsigned int include_flags,
1613 unsigned int exclude_flags,
1614 unsigned int any_flags,
1615 struct gcc_options *opts,
1616 unsigned int lang_mask)
1617 {
1618 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1619 const char * description = NULL;
1620 const char * descrip_extra = "";
1621 size_t i;
1622 unsigned int flag;
1623
1624 /* Sanity check: Make sure that we do not have more
1625 languages than we have bits available to enumerate them. */
1626 gcc_assert ((1U << cl_lang_count) <= CL_MIN_OPTION_CLASS);
1627
1628 /* If we have not done so already, obtain
1629 the desired maximum width of the output. */
1630 if (opts->x_help_columns == 0)
1631 {
1632 opts->x_help_columns = get_terminal_width ();
1633 if (opts->x_help_columns == INT_MAX)
1634 /* Use a reasonable default. */
1635 opts->x_help_columns = 80;
1636 }
1637
1638 /* Decide upon the title for the options that we are going to display. */
1639 for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1640 {
1641 switch (flag & include_flags)
1642 {
1643 case 0:
1644 case CL_DRIVER:
1645 break;
1646
1647 case CL_TARGET:
1648 description = _("The following options are target specific");
1649 break;
1650 case CL_WARNING:
1651 description = _("The following options control compiler warning messages");
1652 break;
1653 case CL_OPTIMIZATION:
1654 description = _("The following options control optimizations");
1655 break;
1656 case CL_COMMON:
1657 description = _("The following options are language-independent");
1658 break;
1659 case CL_PARAMS:
1660 description = _("The following options control parameters");
1661 break;
1662 default:
1663 if (i >= cl_lang_count)
1664 break;
1665 if (exclude_flags & all_langs_mask)
1666 description = _("The following options are specific to just the language ");
1667 else
1668 description = _("The following options are supported by the language ");
1669 descrip_extra = lang_names [i];
1670 break;
1671 }
1672 }
1673
1674 if (description == NULL)
1675 {
1676 if (any_flags == 0)
1677 {
1678 if (include_flags & CL_UNDOCUMENTED)
1679 description = _("The following options are not documented");
1680 else if (include_flags & CL_SEPARATE)
1681 description = _("The following options take separate arguments");
1682 else if (include_flags & CL_JOINED)
1683 description = _("The following options take joined arguments");
1684 else
1685 {
1686 internal_error ("unrecognized %<include_flags 0x%x%> passed "
1687 "to %<print_specific_help%>",
1688 include_flags);
1689 return;
1690 }
1691 }
1692 else
1693 {
1694 if (any_flags & all_langs_mask)
1695 description = _("The following options are language-related");
1696 else
1697 description = _("The following options are language-independent");
1698 }
1699 }
1700
1701 printf ("%s%s:\n", description, descrip_extra);
1702 print_filtered_help (include_flags, exclude_flags, any_flags,
1703 opts->x_help_columns, opts, lang_mask);
1704 }
1705
1706 /* Enable FDO-related flags. */
1707
1708 static void
enable_fdo_optimizations(struct gcc_options * opts,struct gcc_options * opts_set,int value)1709 enable_fdo_optimizations (struct gcc_options *opts,
1710 struct gcc_options *opts_set,
1711 int value)
1712 {
1713 SET_OPTION_IF_UNSET (opts, opts_set, flag_branch_probabilities, value);
1714 SET_OPTION_IF_UNSET (opts, opts_set, flag_profile_values, value);
1715 SET_OPTION_IF_UNSET (opts, opts_set, flag_unroll_loops, value);
1716 SET_OPTION_IF_UNSET (opts, opts_set, flag_peel_loops, value);
1717 SET_OPTION_IF_UNSET (opts, opts_set, flag_tracer, value);
1718 SET_OPTION_IF_UNSET (opts, opts_set, flag_value_profile_transformations,
1719 value);
1720 SET_OPTION_IF_UNSET (opts, opts_set, flag_inline_functions, value);
1721 SET_OPTION_IF_UNSET (opts, opts_set, flag_ipa_cp, value);
1722 if (value)
1723 {
1724 SET_OPTION_IF_UNSET (opts, opts_set, flag_ipa_cp_clone, 1);
1725 SET_OPTION_IF_UNSET (opts, opts_set, flag_ipa_bit_cp, 1);
1726 }
1727 SET_OPTION_IF_UNSET (opts, opts_set, flag_predictive_commoning, value);
1728 SET_OPTION_IF_UNSET (opts, opts_set, flag_split_loops, value);
1729 SET_OPTION_IF_UNSET (opts, opts_set, flag_unswitch_loops, value);
1730 SET_OPTION_IF_UNSET (opts, opts_set, flag_gcse_after_reload, value);
1731 SET_OPTION_IF_UNSET (opts, opts_set, flag_tree_loop_vectorize, value);
1732 SET_OPTION_IF_UNSET (opts, opts_set, flag_tree_slp_vectorize, value);
1733 SET_OPTION_IF_UNSET (opts, opts_set, flag_version_loops_for_strides, value);
1734 SET_OPTION_IF_UNSET (opts, opts_set, flag_vect_cost_model,
1735 VECT_COST_MODEL_DYNAMIC);
1736 SET_OPTION_IF_UNSET (opts, opts_set, flag_tree_loop_distribute_patterns,
1737 value);
1738 SET_OPTION_IF_UNSET (opts, opts_set, flag_loop_interchange, value);
1739 SET_OPTION_IF_UNSET (opts, opts_set, flag_unroll_jam, value);
1740 SET_OPTION_IF_UNSET (opts, opts_set, flag_tree_loop_distribution, value);
1741 }
1742
1743 /* -f{,no-}sanitize{,-recover}= suboptions. */
1744 const struct sanitizer_opts_s sanitizer_opts[] =
1745 {
1746 #define SANITIZER_OPT(name, flags, recover) \
1747 { #name, flags, sizeof #name - 1, recover }
1748 SANITIZER_OPT (address, (SANITIZE_ADDRESS | SANITIZE_USER_ADDRESS), true),
1749 SANITIZER_OPT (kernel-address, (SANITIZE_ADDRESS | SANITIZE_KERNEL_ADDRESS),
1750 true),
1751 SANITIZER_OPT (pointer-compare, SANITIZE_POINTER_COMPARE, true),
1752 SANITIZER_OPT (pointer-subtract, SANITIZE_POINTER_SUBTRACT, true),
1753 SANITIZER_OPT (thread, SANITIZE_THREAD, false),
1754 SANITIZER_OPT (leak, SANITIZE_LEAK, false),
1755 SANITIZER_OPT (shift, SANITIZE_SHIFT, true),
1756 SANITIZER_OPT (shift-base, SANITIZE_SHIFT_BASE, true),
1757 SANITIZER_OPT (shift-exponent, SANITIZE_SHIFT_EXPONENT, true),
1758 SANITIZER_OPT (integer-divide-by-zero, SANITIZE_DIVIDE, true),
1759 SANITIZER_OPT (undefined, SANITIZE_UNDEFINED, true),
1760 SANITIZER_OPT (unreachable, SANITIZE_UNREACHABLE, false),
1761 SANITIZER_OPT (vla-bound, SANITIZE_VLA, true),
1762 SANITIZER_OPT (return, SANITIZE_RETURN, false),
1763 SANITIZER_OPT (null, SANITIZE_NULL, true),
1764 SANITIZER_OPT (signed-integer-overflow, SANITIZE_SI_OVERFLOW, true),
1765 SANITIZER_OPT (bool, SANITIZE_BOOL, true),
1766 SANITIZER_OPT (enum, SANITIZE_ENUM, true),
1767 SANITIZER_OPT (float-divide-by-zero, SANITIZE_FLOAT_DIVIDE, true),
1768 SANITIZER_OPT (float-cast-overflow, SANITIZE_FLOAT_CAST, true),
1769 SANITIZER_OPT (bounds, SANITIZE_BOUNDS, true),
1770 SANITIZER_OPT (bounds-strict, SANITIZE_BOUNDS | SANITIZE_BOUNDS_STRICT, true),
1771 SANITIZER_OPT (alignment, SANITIZE_ALIGNMENT, true),
1772 SANITIZER_OPT (nonnull-attribute, SANITIZE_NONNULL_ATTRIBUTE, true),
1773 SANITIZER_OPT (returns-nonnull-attribute, SANITIZE_RETURNS_NONNULL_ATTRIBUTE,
1774 true),
1775 SANITIZER_OPT (object-size, SANITIZE_OBJECT_SIZE, true),
1776 SANITIZER_OPT (vptr, SANITIZE_VPTR, true),
1777 SANITIZER_OPT (pointer-overflow, SANITIZE_POINTER_OVERFLOW, true),
1778 SANITIZER_OPT (builtin, SANITIZE_BUILTIN, true),
1779 SANITIZER_OPT (all, ~0U, true),
1780 #undef SANITIZER_OPT
1781 { NULL, 0U, 0UL, false }
1782 };
1783
1784 /* -f{,no-}sanitize-coverage= suboptions. */
1785 const struct sanitizer_opts_s coverage_sanitizer_opts[] =
1786 {
1787 #define COVERAGE_SANITIZER_OPT(name, flags) \
1788 { #name, flags, sizeof #name - 1, true }
1789 COVERAGE_SANITIZER_OPT (trace-pc, SANITIZE_COV_TRACE_PC),
1790 COVERAGE_SANITIZER_OPT (trace-cmp, SANITIZE_COV_TRACE_CMP),
1791 #undef COVERAGE_SANITIZER_OPT
1792 { NULL, 0U, 0UL, false }
1793 };
1794
1795 /* A struct for describing a run of chars within a string. */
1796
1797 class string_fragment
1798 {
1799 public:
string_fragment(const char * start,size_t len)1800 string_fragment (const char *start, size_t len)
1801 : m_start (start), m_len (len) {}
1802
1803 const char *m_start;
1804 size_t m_len;
1805 };
1806
1807 /* Specialization of edit_distance_traits for string_fragment,
1808 for use by get_closest_sanitizer_option. */
1809
1810 template <>
1811 struct edit_distance_traits<const string_fragment &>
1812 {
1813 static size_t get_length (const string_fragment &fragment)
1814 {
1815 return fragment.m_len;
1816 }
1817
1818 static const char *get_string (const string_fragment &fragment)
1819 {
1820 return fragment.m_start;
1821 }
1822 };
1823
1824 /* Given ARG, an unrecognized sanitizer option, return the best
1825 matching sanitizer option, or NULL if there isn't one.
1826 OPTS is array of candidate sanitizer options.
1827 CODE is OPT_fsanitize_, OPT_fsanitize_recover_ or
1828 OPT_fsanitize_coverage_.
1829 VALUE is non-zero for the regular form of the option, zero
1830 for the "no-" form (e.g. "-fno-sanitize-recover="). */
1831
1832 static const char *
1833 get_closest_sanitizer_option (const string_fragment &arg,
1834 const struct sanitizer_opts_s *opts,
1835 enum opt_code code, int value)
1836 {
1837 best_match <const string_fragment &, const char*> bm (arg);
1838 for (int i = 0; opts[i].name != NULL; ++i)
1839 {
1840 /* -fsanitize=all is not valid, so don't offer it. */
1841 if (code == OPT_fsanitize_
1842 && opts[i].flag == ~0U
1843 && value)
1844 continue;
1845
1846 /* For -fsanitize-recover= (and not -fno-sanitize-recover=),
1847 don't offer the non-recoverable options. */
1848 if (code == OPT_fsanitize_recover_
1849 && !opts[i].can_recover
1850 && value)
1851 continue;
1852
1853 bm.consider (opts[i].name);
1854 }
1855 return bm.get_best_meaningful_candidate ();
1856 }
1857
1858 /* Parse comma separated sanitizer suboptions from P for option SCODE,
1859 adjust previous FLAGS and return new ones. If COMPLAIN is false,
1860 don't issue diagnostics. */
1861
1862 unsigned int
1863 parse_sanitizer_options (const char *p, location_t loc, int scode,
1864 unsigned int flags, int value, bool complain)
1865 {
1866 enum opt_code code = (enum opt_code) scode;
1867
1868 const struct sanitizer_opts_s *opts;
1869 if (code == OPT_fsanitize_coverage_)
1870 opts = coverage_sanitizer_opts;
1871 else
1872 opts = sanitizer_opts;
1873
1874 while (*p != 0)
1875 {
1876 size_t len, i;
1877 bool found = false;
1878 const char *comma = strchr (p, ',');
1879
1880 if (comma == NULL)
1881 len = strlen (p);
1882 else
1883 len = comma - p;
1884 if (len == 0)
1885 {
1886 p = comma + 1;
1887 continue;
1888 }
1889
1890 /* Check to see if the string matches an option class name. */
1891 for (i = 0; opts[i].name != NULL; ++i)
1892 if (len == opts[i].len && memcmp (p, opts[i].name, len) == 0)
1893 {
1894 /* Handle both -fsanitize and -fno-sanitize cases. */
1895 if (value && opts[i].flag == ~0U)
1896 {
1897 if (code == OPT_fsanitize_)
1898 {
1899 if (complain)
1900 error_at (loc, "%<-fsanitize=all%> option is not valid");
1901 }
1902 else
1903 flags |= ~(SANITIZE_THREAD | SANITIZE_LEAK
1904 | SANITIZE_UNREACHABLE | SANITIZE_RETURN);
1905 }
1906 else if (value)
1907 {
1908 /* Do not enable -fsanitize-recover=unreachable and
1909 -fsanitize-recover=return if -fsanitize-recover=undefined
1910 is selected. */
1911 if (code == OPT_fsanitize_recover_
1912 && opts[i].flag == SANITIZE_UNDEFINED)
1913 flags |= (SANITIZE_UNDEFINED
1914 & ~(SANITIZE_UNREACHABLE | SANITIZE_RETURN));
1915 else
1916 flags |= opts[i].flag;
1917 }
1918 else
1919 flags &= ~opts[i].flag;
1920 found = true;
1921 break;
1922 }
1923
1924 if (! found && complain)
1925 {
1926 const char *hint
1927 = get_closest_sanitizer_option (string_fragment (p, len),
1928 opts, code, value);
1929
1930 const char *suffix;
1931 if (code == OPT_fsanitize_recover_)
1932 suffix = "-recover";
1933 else if (code == OPT_fsanitize_coverage_)
1934 suffix = "-coverage";
1935 else
1936 suffix = "";
1937
1938 if (hint)
1939 error_at (loc,
1940 "unrecognized argument to %<-f%ssanitize%s=%> "
1941 "option: %q.*s; did you mean %qs?",
1942 value ? "" : "no-",
1943 suffix, (int) len, p, hint);
1944 else
1945 error_at (loc,
1946 "unrecognized argument to %<-f%ssanitize%s=%> option: "
1947 "%q.*s", value ? "" : "no-",
1948 suffix, (int) len, p);
1949 }
1950
1951 if (comma == NULL)
1952 break;
1953 p = comma + 1;
1954 }
1955 return flags;
1956 }
1957
1958 /* Parse string values of no_sanitize attribute passed in VALUE.
1959 Values are separated with comma. */
1960
1961 unsigned int
1962 parse_no_sanitize_attribute (char *value)
1963 {
1964 unsigned int flags = 0;
1965 unsigned int i;
1966 char *q = strtok (value, ",");
1967
1968 while (q != NULL)
1969 {
1970 for (i = 0; sanitizer_opts[i].name != NULL; ++i)
1971 if (strcmp (sanitizer_opts[i].name, q) == 0)
1972 {
1973 flags |= sanitizer_opts[i].flag;
1974 if (sanitizer_opts[i].flag == SANITIZE_UNDEFINED)
1975 flags |= SANITIZE_UNDEFINED_NONDEFAULT;
1976 break;
1977 }
1978
1979 if (sanitizer_opts[i].name == NULL)
1980 warning (OPT_Wattributes,
1981 "%qs attribute directive ignored", q);
1982
1983 q = strtok (NULL, ",");
1984 }
1985
1986 return flags;
1987 }
1988
1989 /* Parse -falign-NAME format for a FLAG value. Return individual
1990 parsed integer values into RESULT_VALUES array. If REPORT_ERROR is
1991 set, print error message at LOC location. */
1992
1993 bool
1994 parse_and_check_align_values (const char *flag,
1995 const char *name,
1996 auto_vec<unsigned> &result_values,
1997 bool report_error,
1998 location_t loc)
1999 {
2000 char *str = xstrdup (flag);
2001 for (char *p = strtok (str, ":"); p; p = strtok (NULL, ":"))
2002 {
2003 char *end;
2004 int v = strtol (p, &end, 10);
2005 if (*end != '\0' || v < 0)
2006 {
2007 if (report_error)
2008 error_at (loc, "invalid arguments for %<-falign-%s%> option: %qs",
2009 name, flag);
2010
2011 return false;
2012 }
2013
2014 result_values.safe_push ((unsigned)v);
2015 }
2016
2017 free (str);
2018
2019 /* Check that we have a correct number of values. */
2020 if (result_values.is_empty () || result_values.length () > 4)
2021 {
2022 if (report_error)
2023 error_at (loc, "invalid number of arguments for %<-falign-%s%> "
2024 "option: %qs", name, flag);
2025 return false;
2026 }
2027
2028 for (unsigned i = 0; i < result_values.length (); i++)
2029 if (result_values[i] > MAX_CODE_ALIGN_VALUE)
2030 {
2031 if (report_error)
2032 error_at (loc, "%<-falign-%s%> is not between 0 and %d",
2033 name, MAX_CODE_ALIGN_VALUE);
2034 return false;
2035 }
2036
2037 return true;
2038 }
2039
2040 /* Check that alignment value FLAG for -falign-NAME is valid at a given
2041 location LOC. */
2042
2043 static void
2044 check_alignment_argument (location_t loc, const char *flag, const char *name)
2045 {
2046 auto_vec<unsigned> align_result;
2047 parse_and_check_align_values (flag, name, align_result, true, loc);
2048 }
2049
2050 /* Print help when OPT__help_ is set. */
2051
2052 void
2053 print_help (struct gcc_options *opts, unsigned int lang_mask,
2054 const char *help_option_argument)
2055 {
2056 const char *a = help_option_argument;
2057 unsigned int include_flags = 0;
2058 /* Note - by default we include undocumented options when listing
2059 specific classes. If you only want to see documented options
2060 then add ",^undocumented" to the --help= option. E.g.:
2061
2062 --help=target,^undocumented */
2063 unsigned int exclude_flags = 0;
2064
2065 if (lang_mask == CL_DRIVER)
2066 return;
2067
2068 /* Walk along the argument string, parsing each word in turn.
2069 The format is:
2070 arg = [^]{word}[,{arg}]
2071 word = {optimizers|target|warnings|undocumented|
2072 params|common|<language>} */
2073 while (*a != 0)
2074 {
2075 static const struct
2076 {
2077 const char *string;
2078 unsigned int flag;
2079 }
2080 specifics[] =
2081 {
2082 { "optimizers", CL_OPTIMIZATION },
2083 { "target", CL_TARGET },
2084 { "warnings", CL_WARNING },
2085 { "undocumented", CL_UNDOCUMENTED },
2086 { "params", CL_PARAMS },
2087 { "joined", CL_JOINED },
2088 { "separate", CL_SEPARATE },
2089 { "common", CL_COMMON },
2090 { NULL, 0 }
2091 };
2092 unsigned int *pflags;
2093 const char *comma;
2094 unsigned int lang_flag, specific_flag;
2095 unsigned int len;
2096 unsigned int i;
2097
2098 if (*a == '^')
2099 {
2100 ++a;
2101 if (*a == '\0')
2102 {
2103 error ("missing argument to %qs", "--help=^");
2104 break;
2105 }
2106 pflags = &exclude_flags;
2107 }
2108 else
2109 pflags = &include_flags;
2110
2111 comma = strchr (a, ',');
2112 if (comma == NULL)
2113 len = strlen (a);
2114 else
2115 len = comma - a;
2116 if (len == 0)
2117 {
2118 a = comma + 1;
2119 continue;
2120 }
2121
2122 /* Check to see if the string matches an option class name. */
2123 for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
2124 if (strncasecmp (a, specifics[i].string, len) == 0)
2125 {
2126 specific_flag = specifics[i].flag;
2127 break;
2128 }
2129
2130 /* Check to see if the string matches a language name.
2131 Note - we rely upon the alpha-sorted nature of the entries in
2132 the lang_names array, specifically that shorter names appear
2133 before their longer variants. (i.e. C before C++). That way
2134 when we are attempting to match --help=c for example we will
2135 match with C first and not C++. */
2136 for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
2137 if (strncasecmp (a, lang_names[i], len) == 0)
2138 {
2139 lang_flag = 1U << i;
2140 break;
2141 }
2142
2143 if (specific_flag != 0)
2144 {
2145 if (lang_flag == 0)
2146 *pflags |= specific_flag;
2147 else
2148 {
2149 /* The option's argument matches both the start of a
2150 language name and the start of an option class name.
2151 We have a special case for when the user has
2152 specified "--help=c", but otherwise we have to issue
2153 a warning. */
2154 if (strncasecmp (a, "c", len) == 0)
2155 *pflags |= lang_flag;
2156 else
2157 warning (0,
2158 "%<--help%> argument %q.*s is ambiguous, "
2159 "please be more specific",
2160 len, a);
2161 }
2162 }
2163 else if (lang_flag != 0)
2164 *pflags |= lang_flag;
2165 else
2166 warning (0,
2167 "unrecognized argument to %<--help=%> option: %q.*s",
2168 len, a);
2169
2170 if (comma == NULL)
2171 break;
2172 a = comma + 1;
2173 }
2174
2175 /* We started using PerFunction/Optimization for parameters and
2176 a warning. We should exclude these from optimization options. */
2177 if (include_flags & CL_OPTIMIZATION)
2178 exclude_flags |= CL_WARNING;
2179 if (!(include_flags & CL_PARAMS))
2180 exclude_flags |= CL_PARAMS;
2181
2182 if (include_flags)
2183 print_specific_help (include_flags, exclude_flags, 0, opts,
2184 lang_mask);
2185 }
2186
2187 /* Handle target- and language-independent options. Return zero to
2188 generate an "unknown option" message. Only options that need
2189 extra handling need to be listed here; if you simply want
2190 DECODED->value assigned to a variable, it happens automatically. */
2191
2192 bool
2193 common_handle_option (struct gcc_options *opts,
2194 struct gcc_options *opts_set,
2195 const struct cl_decoded_option *decoded,
2196 unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
2197 location_t loc,
2198 const struct cl_option_handlers *handlers,
2199 diagnostic_context *dc,
2200 void (*target_option_override_hook) (void))
2201 {
2202 size_t scode = decoded->opt_index;
2203 const char *arg = decoded->arg;
2204 HOST_WIDE_INT value = decoded->value;
2205 enum opt_code code = (enum opt_code) scode;
2206
2207 gcc_assert (decoded->canonical_option_num_elements <= 2);
2208
2209 switch (code)
2210 {
2211 case OPT__help:
2212 {
2213 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
2214 unsigned int undoc_mask;
2215 unsigned int i;
2216
2217 if (lang_mask == CL_DRIVER)
2218 break;
2219
2220 undoc_mask = ((opts->x_verbose_flag | opts->x_extra_warnings)
2221 ? 0
2222 : CL_UNDOCUMENTED);
2223 target_option_override_hook ();
2224 /* First display any single language specific options. */
2225 for (i = 0; i < cl_lang_count; i++)
2226 print_specific_help
2227 (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0, opts,
2228 lang_mask);
2229 /* Next display any multi language specific options. */
2230 print_specific_help (0, undoc_mask, all_langs_mask, opts, lang_mask);
2231 /* Then display any remaining, non-language options. */
2232 for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
2233 if (i != CL_DRIVER)
2234 print_specific_help (i, undoc_mask, 0, opts, lang_mask);
2235 opts->x_exit_after_options = true;
2236 break;
2237 }
2238
2239 case OPT__target_help:
2240 if (lang_mask == CL_DRIVER)
2241 break;
2242
2243 target_option_override_hook ();
2244 print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0, opts, lang_mask);
2245 opts->x_exit_after_options = true;
2246 break;
2247
2248 case OPT__help_:
2249 {
2250 help_option_arguments.safe_push (arg);
2251 opts->x_exit_after_options = true;
2252 break;
2253 }
2254
2255 case OPT__version:
2256 if (lang_mask == CL_DRIVER)
2257 break;
2258
2259 opts->x_exit_after_options = true;
2260 break;
2261
2262 case OPT__completion_:
2263 break;
2264
2265 case OPT_fsanitize_:
2266 opts->x_flag_sanitize
2267 = parse_sanitizer_options (arg, loc, code,
2268 opts->x_flag_sanitize, value, true);
2269
2270 /* Kernel ASan implies normal ASan but does not yet support
2271 all features. */
2272 if (opts->x_flag_sanitize & SANITIZE_KERNEL_ADDRESS)
2273 {
2274 SET_OPTION_IF_UNSET (opts, opts_set,
2275 param_asan_instrumentation_with_call_threshold,
2276 0);
2277 SET_OPTION_IF_UNSET (opts, opts_set, param_asan_globals, 0);
2278 SET_OPTION_IF_UNSET (opts, opts_set, param_asan_stack, 0);
2279 SET_OPTION_IF_UNSET (opts, opts_set, param_asan_protect_allocas, 0);
2280 SET_OPTION_IF_UNSET (opts, opts_set, param_asan_use_after_return, 0);
2281 }
2282 break;
2283
2284 case OPT_fsanitize_recover_:
2285 opts->x_flag_sanitize_recover
2286 = parse_sanitizer_options (arg, loc, code,
2287 opts->x_flag_sanitize_recover, value, true);
2288 break;
2289
2290 case OPT_fasan_shadow_offset_:
2291 /* Deferred. */
2292 break;
2293
2294 case OPT_fsanitize_address_use_after_scope:
2295 opts->x_flag_sanitize_address_use_after_scope = value;
2296 break;
2297
2298 case OPT_fsanitize_recover:
2299 if (value)
2300 opts->x_flag_sanitize_recover
2301 |= (SANITIZE_UNDEFINED | SANITIZE_UNDEFINED_NONDEFAULT)
2302 & ~(SANITIZE_UNREACHABLE | SANITIZE_RETURN);
2303 else
2304 opts->x_flag_sanitize_recover
2305 &= ~(SANITIZE_UNDEFINED | SANITIZE_UNDEFINED_NONDEFAULT);
2306 break;
2307
2308 case OPT_fsanitize_coverage_:
2309 opts->x_flag_sanitize_coverage
2310 = parse_sanitizer_options (arg, loc, code,
2311 opts->x_flag_sanitize_coverage, value, true);
2312 break;
2313
2314 case OPT_O:
2315 case OPT_Os:
2316 case OPT_Ofast:
2317 case OPT_Og:
2318 /* Currently handled in a prescan. */
2319 break;
2320
2321 case OPT_Werror:
2322 dc->warning_as_error_requested = value;
2323 break;
2324
2325 case OPT_Werror_:
2326 if (lang_mask == CL_DRIVER)
2327 break;
2328
2329 enable_warning_as_error (arg, value, lang_mask, handlers,
2330 opts, opts_set, loc, dc);
2331 break;
2332
2333 case OPT_Wfatal_errors:
2334 dc->fatal_errors = value;
2335 break;
2336
2337 case OPT_Wstack_usage_:
2338 opts->x_flag_stack_usage_info = value != -1;
2339 break;
2340
2341 case OPT_Wstrict_aliasing:
2342 set_Wstrict_aliasing (opts, value);
2343 break;
2344
2345 case OPT_Wstrict_overflow:
2346 opts->x_warn_strict_overflow = (value
2347 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
2348 : 0);
2349 break;
2350
2351 case OPT_Wsystem_headers:
2352 dc->dc_warn_system_headers = value;
2353 break;
2354
2355 case OPT_aux_info:
2356 opts->x_flag_gen_aux_info = 1;
2357 break;
2358
2359 case OPT_auxbase_strip:
2360 {
2361 char *tmp = xstrdup (arg);
2362 strip_off_ending (tmp, strlen (tmp));
2363 if (tmp[0])
2364 opts->x_aux_base_name = tmp;
2365 else
2366 free (tmp);
2367 }
2368 break;
2369
2370 case OPT_d:
2371 decode_d_option (arg, opts, loc, dc);
2372 break;
2373
2374 case OPT_fcall_used_:
2375 case OPT_fcall_saved_:
2376 /* Deferred. */
2377 break;
2378
2379 case OPT_fdbg_cnt_:
2380 /* Deferred. */
2381 break;
2382
2383 case OPT_fdbg_cnt_list:
2384 /* Deferred. */
2385 opts->x_exit_after_options = true;
2386 break;
2387
2388 case OPT_fdebug_prefix_map_:
2389 case OPT_ffile_prefix_map_:
2390 /* Deferred. */
2391 break;
2392
2393 case OPT_fdebug_regex_map_:
2394 /* Deferred. */
2395 break;
2396
2397 case OPT_fcallgraph_info:
2398 opts->x_flag_callgraph_info = CALLGRAPH_INFO_NAKED;
2399 break;
2400
2401 case OPT_fcallgraph_info_:
2402 {
2403 char *my_arg, *p;
2404 my_arg = xstrdup (arg);
2405 p = strtok (my_arg, ",");
2406 while (p)
2407 {
2408 if (strcmp (p, "su") == 0)
2409 {
2410 opts->x_flag_callgraph_info |= CALLGRAPH_INFO_STACK_USAGE;
2411 opts->x_flag_stack_usage_info = true;
2412 }
2413 else if (strcmp (p, "da") == 0)
2414 opts->x_flag_callgraph_info |= CALLGRAPH_INFO_DYNAMIC_ALLOC;
2415 else
2416 return 0;
2417 p = strtok (NULL, ",");
2418 }
2419 free (my_arg);
2420 }
2421 break;
2422
2423 case OPT_fdiagnostics_show_location_:
2424 diagnostic_prefixing_rule (dc) = (diagnostic_prefixing_rule_t) value;
2425 break;
2426
2427 case OPT_fdiagnostics_show_caret:
2428 dc->show_caret = value;
2429 break;
2430
2431 case OPT_fdiagnostics_show_labels:
2432 dc->show_labels_p = value;
2433 break;
2434
2435 case OPT_fdiagnostics_show_line_numbers:
2436 dc->show_line_numbers_p = value;
2437 break;
2438
2439 case OPT_fdiagnostics_color_:
2440 diagnostic_color_init (dc, value);
2441 break;
2442
2443 case OPT_fdiagnostics_urls_:
2444 diagnostic_urls_init (dc, value);
2445 break;
2446
2447 case OPT_fdiagnostics_format_:
2448 diagnostic_output_format_init (dc,
2449 (enum diagnostics_output_format)value);
2450 break;
2451
2452 case OPT_fdiagnostics_parseable_fixits:
2453 dc->parseable_fixits_p = value;
2454 break;
2455
2456 case OPT_fdiagnostics_show_cwe:
2457 dc->show_cwe = value;
2458 break;
2459
2460 case OPT_fdiagnostics_path_format_:
2461 dc->path_format = (enum diagnostic_path_format)value;
2462 break;
2463
2464 case OPT_fdiagnostics_show_path_depths:
2465 dc->show_path_depths = value;
2466 break;
2467
2468 case OPT_fdiagnostics_show_option:
2469 dc->show_option_requested = value;
2470 break;
2471
2472 case OPT_fdiagnostics_minimum_margin_width_:
2473 dc->min_margin_width = value;
2474 break;
2475
2476 case OPT_fdump_:
2477 /* Deferred. */
2478 break;
2479
2480 case OPT_ffast_math:
2481 set_fast_math_flags (opts, value);
2482 break;
2483
2484 case OPT_funsafe_math_optimizations:
2485 set_unsafe_math_optimizations_flags (opts, value);
2486 break;
2487
2488 case OPT_ffixed_:
2489 /* Deferred. */
2490 break;
2491
2492 case OPT_finline_limit_:
2493 SET_OPTION_IF_UNSET (opts, opts_set, param_max_inline_insns_single,
2494 value / 2);
2495 SET_OPTION_IF_UNSET (opts, opts_set, param_max_inline_insns_auto,
2496 value / 2);
2497 break;
2498
2499 case OPT_finstrument_functions_exclude_function_list_:
2500 add_comma_separated_to_vector
2501 (&opts->x_flag_instrument_functions_exclude_functions, arg);
2502 break;
2503
2504 case OPT_finstrument_functions_exclude_file_list_:
2505 add_comma_separated_to_vector
2506 (&opts->x_flag_instrument_functions_exclude_files, arg);
2507 break;
2508
2509 case OPT_fmessage_length_:
2510 pp_set_line_maximum_length (dc->printer, value);
2511 diagnostic_set_caret_max_width (dc, value);
2512 break;
2513
2514 case OPT_fopt_info:
2515 case OPT_fopt_info_:
2516 /* Deferred. */
2517 break;
2518
2519 case OPT_foffload_:
2520 {
2521 const char *p = arg;
2522 opts->x_flag_disable_hsa = true;
2523 while (*p != 0)
2524 {
2525 const char *comma = strchr (p, ',');
2526
2527 if ((strncmp (p, "disable", 7) == 0)
2528 && (p[7] == ',' || p[7] == '\0'))
2529 {
2530 opts->x_flag_disable_hsa = true;
2531 break;
2532 }
2533
2534 if ((strncmp (p, "hsa", 3) == 0)
2535 && (p[3] == ',' || p[3] == '\0'))
2536 {
2537 #ifdef ENABLE_HSA
2538 opts->x_flag_disable_hsa = false;
2539 #else
2540 sorry ("HSA has not been enabled during configuration");
2541 #endif
2542 }
2543 if (!comma)
2544 break;
2545 p = comma + 1;
2546 }
2547 break;
2548 }
2549
2550 #ifndef ACCEL_COMPILER
2551 case OPT_foffload_abi_:
2552 error_at (loc, "%<-foffload-abi%> option can be specified only for "
2553 "offload compiler");
2554 break;
2555 #endif
2556
2557 case OPT_fpack_struct_:
2558 if (value <= 0 || (value & (value - 1)) || value > 16)
2559 error_at (loc,
2560 "structure alignment must be a small power of two, not %wu",
2561 value);
2562 else
2563 opts->x_initial_max_fld_align = value;
2564 break;
2565
2566 case OPT_fplugin_:
2567 case OPT_fplugin_arg_:
2568 /* Deferred. */
2569 break;
2570
2571 case OPT_fprofile_use_:
2572 opts->x_profile_data_prefix = xstrdup (arg);
2573 opts->x_flag_profile_use = true;
2574 value = true;
2575 /* No break here - do -fprofile-use processing. */
2576 /* FALLTHRU */
2577 case OPT_fprofile_use:
2578 enable_fdo_optimizations (opts, opts_set, value);
2579 SET_OPTION_IF_UNSET (opts, opts_set, flag_profile_reorder_functions,
2580 value);
2581 /* Indirect call profiling should do all useful transformations
2582 speculative devirtualization does. */
2583 if (opts->x_flag_value_profile_transformations)
2584 SET_OPTION_IF_UNSET (opts, opts_set, flag_devirtualize_speculatively,
2585 false);
2586 break;
2587
2588 case OPT_fauto_profile_:
2589 opts->x_auto_profile_file = xstrdup (arg);
2590 opts->x_flag_auto_profile = true;
2591 value = true;
2592 /* No break here - do -fauto-profile processing. */
2593 /* FALLTHRU */
2594 case OPT_fauto_profile:
2595 enable_fdo_optimizations (opts, opts_set, value);
2596 SET_OPTION_IF_UNSET (opts, opts_set, flag_profile_correction, value);
2597 SET_OPTION_IF_UNSET (opts, opts_set,
2598 param_early_inliner_max_iterations, 10);
2599 break;
2600
2601 case OPT_fprofile_generate_:
2602 opts->x_profile_data_prefix = xstrdup (arg);
2603 value = true;
2604 /* No break here - do -fprofile-generate processing. */
2605 /* FALLTHRU */
2606 case OPT_fprofile_generate:
2607 SET_OPTION_IF_UNSET (opts, opts_set, profile_arc_flag, value);
2608 SET_OPTION_IF_UNSET (opts, opts_set, flag_profile_values, value);
2609 SET_OPTION_IF_UNSET (opts, opts_set, flag_inline_functions, value);
2610 SET_OPTION_IF_UNSET (opts, opts_set, flag_ipa_bit_cp, value);
2611 break;
2612
2613 case OPT_fpatchable_function_entry_:
2614 {
2615 char *patch_area_arg = xstrdup (arg);
2616 char *comma = strchr (patch_area_arg, ',');
2617 if (comma)
2618 {
2619 *comma = '\0';
2620 function_entry_patch_area_size =
2621 integral_argument (patch_area_arg);
2622 function_entry_patch_area_start =
2623 integral_argument (comma + 1);
2624 }
2625 else
2626 {
2627 function_entry_patch_area_size =
2628 integral_argument (patch_area_arg);
2629 function_entry_patch_area_start = 0;
2630 }
2631 if (function_entry_patch_area_size < 0
2632 || function_entry_patch_area_start < 0
2633 || function_entry_patch_area_size
2634 < function_entry_patch_area_start)
2635 error ("invalid arguments for %<-fpatchable_function_entry%>");
2636 free (patch_area_arg);
2637 }
2638 break;
2639
2640 case OPT_ftree_vectorize:
2641 /* Automatically sets -ftree-loop-vectorize and
2642 -ftree-slp-vectorize. Nothing more to do here. */
2643 break;
2644 case OPT_fshow_column:
2645 dc->show_column = value;
2646 break;
2647
2648 case OPT_frandom_seed:
2649 /* The real switch is -fno-random-seed. */
2650 if (value)
2651 return false;
2652 /* Deferred. */
2653 break;
2654
2655 case OPT_frandom_seed_:
2656 /* Deferred. */
2657 break;
2658
2659 case OPT_fsched_verbose_:
2660 #ifdef INSN_SCHEDULING
2661 /* Handled with Var in common.opt. */
2662 break;
2663 #else
2664 return false;
2665 #endif
2666
2667 case OPT_fsched_stalled_insns_:
2668 opts->x_flag_sched_stalled_insns = value;
2669 if (opts->x_flag_sched_stalled_insns == 0)
2670 opts->x_flag_sched_stalled_insns = -1;
2671 break;
2672
2673 case OPT_fsched_stalled_insns_dep_:
2674 opts->x_flag_sched_stalled_insns_dep = value;
2675 break;
2676
2677 case OPT_fstack_check_:
2678 if (!strcmp (arg, "no"))
2679 opts->x_flag_stack_check = NO_STACK_CHECK;
2680 else if (!strcmp (arg, "generic"))
2681 /* This is the old stack checking method. */
2682 opts->x_flag_stack_check = STACK_CHECK_BUILTIN
2683 ? FULL_BUILTIN_STACK_CHECK
2684 : GENERIC_STACK_CHECK;
2685 else if (!strcmp (arg, "specific"))
2686 /* This is the new stack checking method. */
2687 opts->x_flag_stack_check = STACK_CHECK_BUILTIN
2688 ? FULL_BUILTIN_STACK_CHECK
2689 : STACK_CHECK_STATIC_BUILTIN
2690 ? STATIC_BUILTIN_STACK_CHECK
2691 : GENERIC_STACK_CHECK;
2692 else
2693 warning_at (loc, 0, "unknown stack check parameter %qs", arg);
2694 break;
2695
2696 case OPT_fstack_limit:
2697 /* The real switch is -fno-stack-limit. */
2698 if (value)
2699 return false;
2700 /* Deferred. */
2701 break;
2702
2703 case OPT_fstack_limit_register_:
2704 case OPT_fstack_limit_symbol_:
2705 /* Deferred. */
2706 break;
2707
2708 case OPT_fstack_usage:
2709 opts->x_flag_stack_usage = value;
2710 opts->x_flag_stack_usage_info = value != 0;
2711 break;
2712
2713 case OPT_g:
2714 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg, opts, opts_set,
2715 loc);
2716 break;
2717
2718 case OPT_gdwarf:
2719 if (arg && strlen (arg) != 0)
2720 {
2721 error_at (loc, "%<-gdwarf%s%> is ambiguous; "
2722 "use %<-gdwarf-%s%> for DWARF version "
2723 "or %<-gdwarf%> %<-g%s%> for debug level", arg, arg, arg);
2724 break;
2725 }
2726 else
2727 value = opts->x_dwarf_version;
2728
2729 /* FALLTHRU */
2730 case OPT_gdwarf_:
2731 if (value < 2 || value > 5)
2732 error_at (loc, "dwarf version %wu is not supported", value);
2733 else
2734 opts->x_dwarf_version = value;
2735 set_debug_level (DWARF2_DEBUG, false, "", opts, opts_set, loc);
2736 break;
2737
2738 case OPT_gsplit_dwarf:
2739 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, "", opts, opts_set,
2740 loc);
2741 break;
2742
2743 case OPT_ggdb:
2744 set_debug_level (NO_DEBUG, 2, arg, opts, opts_set, loc);
2745 break;
2746
2747 case OPT_gstabs:
2748 case OPT_gstabs_:
2749 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg, opts, opts_set,
2750 loc);
2751 break;
2752
2753 case OPT_gvms:
2754 set_debug_level (VMS_DEBUG, false, arg, opts, opts_set, loc);
2755 break;
2756
2757 case OPT_gxcoff:
2758 case OPT_gxcoff_:
2759 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg, opts, opts_set,
2760 loc);
2761 break;
2762
2763 case OPT_gz:
2764 case OPT_gz_:
2765 /* Handled completely via specs. */
2766 break;
2767
2768 case OPT_pedantic_errors:
2769 dc->pedantic_errors = 1;
2770 control_warning_option (OPT_Wpedantic, DK_ERROR, NULL, value,
2771 loc, lang_mask,
2772 handlers, opts, opts_set,
2773 dc);
2774 break;
2775
2776 case OPT_flto:
2777 opts->x_flag_lto = value ? "" : NULL;
2778 break;
2779
2780 case OPT_flto_:
2781 if (strcmp (arg, "none") != 0
2782 && strcmp (arg, "jobserver") != 0
2783 && strcmp (arg, "auto") != 0
2784 && atoi (arg) == 0)
2785 error_at (loc,
2786 "unrecognized argument to %<-flto=%> option: %qs", arg);
2787 break;
2788
2789 case OPT_w:
2790 dc->dc_inhibit_warnings = true;
2791 break;
2792
2793 case OPT_fmax_errors_:
2794 dc->max_errors = value;
2795 break;
2796
2797 case OPT_fuse_ld_bfd:
2798 case OPT_fuse_ld_gold:
2799 case OPT_fuse_ld_lld:
2800 case OPT_fuse_linker_plugin:
2801 /* No-op. Used by the driver and passed to us because it starts with f.*/
2802 break;
2803
2804 case OPT_fwrapv:
2805 if (value)
2806 opts->x_flag_trapv = 0;
2807 break;
2808
2809 case OPT_ftrapv:
2810 if (value)
2811 opts->x_flag_wrapv = 0;
2812 break;
2813
2814 case OPT_fstrict_overflow:
2815 opts->x_flag_wrapv = !value;
2816 opts->x_flag_wrapv_pointer = !value;
2817 if (!value)
2818 opts->x_flag_trapv = 0;
2819 break;
2820
2821 case OPT_fipa_icf:
2822 opts->x_flag_ipa_icf_functions = value;
2823 opts->x_flag_ipa_icf_variables = value;
2824 break;
2825
2826 case OPT_falign_loops_:
2827 check_alignment_argument (loc, arg, "loops");
2828 break;
2829
2830 case OPT_falign_jumps_:
2831 check_alignment_argument (loc, arg, "jumps");
2832 break;
2833
2834 case OPT_falign_labels_:
2835 check_alignment_argument (loc, arg, "labels");
2836 break;
2837
2838 case OPT_falign_functions_:
2839 check_alignment_argument (loc, arg, "functions");
2840 break;
2841
2842 default:
2843 /* If the flag was handled in a standard way, assume the lack of
2844 processing here is intentional. */
2845 gcc_assert (option_flag_var (scode, opts));
2846 break;
2847 }
2848
2849 common_handle_option_auto (opts, opts_set, decoded, lang_mask, kind,
2850 loc, handlers, dc);
2851 return true;
2852 }
2853
2854 /* Used to set the level of strict aliasing warnings in OPTS,
2855 when no level is specified (i.e., when -Wstrict-aliasing, and not
2856 -Wstrict-aliasing=level was given).
2857 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2858 and 0 otherwise. After calling this function, wstrict_aliasing will be
2859 set to the default value of -Wstrict_aliasing=level, currently 3. */
2860 static void
2861 set_Wstrict_aliasing (struct gcc_options *opts, int onoff)
2862 {
2863 gcc_assert (onoff == 0 || onoff == 1);
2864 if (onoff != 0)
2865 opts->x_warn_strict_aliasing = 3;
2866 else
2867 opts->x_warn_strict_aliasing = 0;
2868 }
2869
2870 /* The following routines are useful in setting all the flags that
2871 -ffast-math and -fno-fast-math imply. */
2872 static void
2873 set_fast_math_flags (struct gcc_options *opts, int set)
2874 {
2875 if (!opts->frontend_set_flag_unsafe_math_optimizations)
2876 {
2877 opts->x_flag_unsafe_math_optimizations = set;
2878 set_unsafe_math_optimizations_flags (opts, set);
2879 }
2880 if (!opts->frontend_set_flag_finite_math_only)
2881 opts->x_flag_finite_math_only = set;
2882 if (!opts->frontend_set_flag_errno_math)
2883 opts->x_flag_errno_math = !set;
2884 if (set)
2885 {
2886 if (opts->frontend_set_flag_excess_precision == EXCESS_PRECISION_DEFAULT)
2887 opts->x_flag_excess_precision
2888 = set ? EXCESS_PRECISION_FAST : EXCESS_PRECISION_DEFAULT;
2889 if (!opts->frontend_set_flag_signaling_nans)
2890 opts->x_flag_signaling_nans = 0;
2891 if (!opts->frontend_set_flag_rounding_math)
2892 opts->x_flag_rounding_math = 0;
2893 if (!opts->frontend_set_flag_cx_limited_range)
2894 opts->x_flag_cx_limited_range = 1;
2895 }
2896 }
2897
2898 /* When -funsafe-math-optimizations is set the following
2899 flags are set as well. */
2900 static void
2901 set_unsafe_math_optimizations_flags (struct gcc_options *opts, int set)
2902 {
2903 if (!opts->frontend_set_flag_trapping_math)
2904 opts->x_flag_trapping_math = !set;
2905 if (!opts->frontend_set_flag_signed_zeros)
2906 opts->x_flag_signed_zeros = !set;
2907 if (!opts->frontend_set_flag_associative_math)
2908 opts->x_flag_associative_math = set;
2909 if (!opts->frontend_set_flag_reciprocal_math)
2910 opts->x_flag_reciprocal_math = set;
2911 }
2912
2913 /* Return true iff flags in OPTS are set as if -ffast-math. */
2914 bool
2915 fast_math_flags_set_p (const struct gcc_options *opts)
2916 {
2917 return (!opts->x_flag_trapping_math
2918 && opts->x_flag_unsafe_math_optimizations
2919 && opts->x_flag_finite_math_only
2920 && !opts->x_flag_signed_zeros
2921 && !opts->x_flag_errno_math
2922 && opts->x_flag_excess_precision == EXCESS_PRECISION_FAST);
2923 }
2924
2925 /* Return true iff flags are set as if -ffast-math but using the flags stored
2926 in the struct cl_optimization structure. */
2927 bool
2928 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2929 {
2930 return (!opt->x_flag_trapping_math
2931 && opt->x_flag_unsafe_math_optimizations
2932 && opt->x_flag_finite_math_only
2933 && !opt->x_flag_signed_zeros
2934 && !opt->x_flag_errno_math);
2935 }
2936
2937 /* Handle a debug output -g switch for options OPTS
2938 (OPTS_SET->x_write_symbols storing whether a debug type was passed
2939 explicitly), location LOC. EXTENDED is true or false to support
2940 extended output (2 is special and means "-ggdb" was given). */
2941 static void
2942 set_debug_level (enum debug_info_type type, int extended, const char *arg,
2943 struct gcc_options *opts, struct gcc_options *opts_set,
2944 location_t loc)
2945 {
2946 opts->x_use_gnu_debug_info_extensions = extended;
2947
2948 if (type == NO_DEBUG)
2949 {
2950 if (opts->x_write_symbols == NO_DEBUG)
2951 {
2952 opts->x_write_symbols = PREFERRED_DEBUGGING_TYPE;
2953
2954 if (extended == 2)
2955 {
2956 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO
2957 opts->x_write_symbols = DWARF2_DEBUG;
2958 #elif defined DBX_DEBUGGING_INFO
2959 opts->x_write_symbols = DBX_DEBUG;
2960 #endif
2961 }
2962
2963 if (opts->x_write_symbols == NO_DEBUG)
2964 warning_at (loc, 0, "target system does not support debug output");
2965 }
2966 }
2967 else
2968 {
2969 /* Does it conflict with an already selected type? */
2970 if (opts_set->x_write_symbols != NO_DEBUG
2971 && opts->x_write_symbols != NO_DEBUG
2972 && type != opts->x_write_symbols)
2973 error_at (loc, "debug format %qs conflicts with prior selection",
2974 debug_type_names[type]);
2975 opts->x_write_symbols = type;
2976 opts_set->x_write_symbols = type;
2977 }
2978
2979 /* A debug flag without a level defaults to level 2.
2980 If off or at level 1, set it to level 2, but if already
2981 at level 3, don't lower it. */
2982 if (*arg == '\0')
2983 {
2984 if (opts->x_debug_info_level < DINFO_LEVEL_NORMAL)
2985 opts->x_debug_info_level = DINFO_LEVEL_NORMAL;
2986 }
2987 else
2988 {
2989 int argval = integral_argument (arg);
2990 if (argval == -1)
2991 error_at (loc, "unrecognized debug output level %qs", arg);
2992 else if (argval > 3)
2993 error_at (loc, "debug output level %qs is too high", arg);
2994 else
2995 opts->x_debug_info_level = (enum debug_info_levels) argval;
2996 }
2997 }
2998
2999 /* Arrange to dump core on error for diagnostic context DC. (The
3000 regular error message is still printed first, except in the case of
3001 abort ().) */
3002
3003 static void
3004 setup_core_dumping (diagnostic_context *dc)
3005 {
3006 #ifdef SIGABRT
3007 signal (SIGABRT, SIG_DFL);
3008 #endif
3009 #if defined(HAVE_SETRLIMIT)
3010 {
3011 struct rlimit rlim;
3012 if (getrlimit (RLIMIT_CORE, &rlim) != 0)
3013 fatal_error (input_location, "getting core file size maximum limit: %m");
3014 rlim.rlim_cur = rlim.rlim_max;
3015 if (setrlimit (RLIMIT_CORE, &rlim) != 0)
3016 fatal_error (input_location,
3017 "setting core file size limit to maximum: %m");
3018 }
3019 #endif
3020 diagnostic_abort_on_error (dc);
3021 }
3022
3023 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
3024 diagnostic context DC. */
3025
3026 static void
3027 decode_d_option (const char *arg, struct gcc_options *opts,
3028 location_t loc, diagnostic_context *dc)
3029 {
3030 int c;
3031
3032 while (*arg)
3033 switch (c = *arg++)
3034 {
3035 case 'A':
3036 opts->x_flag_debug_asm = 1;
3037 break;
3038 case 'p':
3039 opts->x_flag_print_asm_name = 1;
3040 break;
3041 case 'P':
3042 opts->x_flag_dump_rtl_in_asm = 1;
3043 opts->x_flag_print_asm_name = 1;
3044 break;
3045 case 'x':
3046 opts->x_rtl_dump_and_exit = 1;
3047 break;
3048 case 'D': /* These are handled by the preprocessor. */
3049 case 'I':
3050 case 'M':
3051 case 'N':
3052 case 'U':
3053 break;
3054 case 'H':
3055 setup_core_dumping (dc);
3056 break;
3057 case 'a':
3058 opts->x_flag_dump_all_passed = true;
3059 break;
3060
3061 default:
3062 warning_at (loc, 0, "unrecognized gcc debugging option: %c", c);
3063 break;
3064 }
3065 }
3066
3067 /* Enable (or disable if VALUE is 0) a warning option ARG (language
3068 mask LANG_MASK, option handlers HANDLERS) as an error for option
3069 structures OPTS and OPTS_SET, diagnostic context DC (possibly
3070 NULL), location LOC. This is used by -Werror=. */
3071
3072 static void
3073 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
3074 const struct cl_option_handlers *handlers,
3075 struct gcc_options *opts,
3076 struct gcc_options *opts_set,
3077 location_t loc, diagnostic_context *dc)
3078 {
3079 char *new_option;
3080 int option_index;
3081
3082 new_option = XNEWVEC (char, strlen (arg) + 2);
3083 new_option[0] = 'W';
3084 strcpy (new_option + 1, arg);
3085 option_index = find_opt (new_option, lang_mask);
3086 if (option_index == OPT_SPECIAL_unknown)
3087 {
3088 option_proposer op;
3089 const char *hint = op.suggest_option (new_option);
3090 if (hint)
3091 error_at (loc, "%<-W%serror=%s%>: no option %<-%s%>;"
3092 " did you mean %<-%s%>?", value ? "" : "no-",
3093 arg, new_option, hint);
3094 else
3095 error_at (loc, "%<-W%serror=%s%>: no option %<-%s%>",
3096 value ? "" : "no-", arg, new_option);
3097 }
3098 else if (!(cl_options[option_index].flags & CL_WARNING))
3099 error_at (loc, "%<-Werror=%s%>: %<-%s%> is not an option that "
3100 "controls warnings", arg, new_option);
3101 else
3102 {
3103 const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
3104 const char *arg = NULL;
3105
3106 if (cl_options[option_index].flags & CL_JOINED)
3107 arg = new_option + cl_options[option_index].opt_len;
3108 control_warning_option (option_index, (int) kind, arg, value,
3109 loc, lang_mask,
3110 handlers, opts, opts_set, dc);
3111 }
3112 free (new_option);
3113 }
3114
3115 /* Return malloced memory for the name of the option OPTION_INDEX
3116 which enabled a diagnostic (context CONTEXT), originally of type
3117 ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
3118 as -Werror. */
3119
3120 char *
3121 option_name (diagnostic_context *context, int option_index,
3122 diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
3123 {
3124 if (option_index)
3125 {
3126 /* A warning classified as an error. */
3127 if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
3128 && diag_kind == DK_ERROR)
3129 return concat (cl_options[OPT_Werror_].opt_text,
3130 /* Skip over "-W". */
3131 cl_options[option_index].opt_text + 2,
3132 NULL);
3133 /* A warning with option. */
3134 else
3135 return xstrdup (cl_options[option_index].opt_text);
3136 }
3137 /* A warning without option classified as an error. */
3138 else if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
3139 || diag_kind == DK_WARNING)
3140 && context->warning_as_error_requested)
3141 return xstrdup (cl_options[OPT_Werror].opt_text);
3142 else
3143 return NULL;
3144 }
3145
3146 /* Get the page within the documentation for this option. */
3147
3148 static const char *
3149 get_option_html_page (int option_index)
3150 {
3151 const cl_option *cl_opt = &cl_options[option_index];
3152
3153 /* Analyzer options are on their own page. */
3154 if (strstr(cl_opt->opt_text, "analyzer-"))
3155 return "gcc/Static-Analyzer-Options.html";
3156
3157 #ifdef CL_Fortran
3158 if ((cl_opt->flags & CL_Fortran) != 0
3159 /* If it is option common to both C/C++ and Fortran, it is documented
3160 in gcc/ rather than gfortran/ docs. */
3161 && (cl_opt->flags & CL_C) == 0
3162 #ifdef CL_CXX
3163 && (cl_opt->flags & CL_CXX) == 0
3164 #endif
3165 )
3166 return "gfortran/Error-and-Warning-Options.html";
3167 #endif
3168
3169 return "gcc/Warning-Options.html";
3170 }
3171
3172 /* Return malloced memory for a URL describing the option OPTION_INDEX
3173 which enabled a diagnostic (context CONTEXT). */
3174
3175 char *
3176 get_option_url (diagnostic_context *, int option_index)
3177 {
3178 if (option_index)
3179 return concat (/* DOCUMENTATION_ROOT_URL should be supplied via -D by
3180 the Makefile (see --with-documentation-root-url), and
3181 should have a trailing slash. */
3182 DOCUMENTATION_ROOT_URL,
3183
3184 /* get_option_html_page will return something like
3185 "gcc/Warning-Options.html". */
3186 get_option_html_page (option_index),
3187
3188 /* Expect an anchor of the form "index-Wfoo" e.g.
3189 <a name="index-Wformat"></a>, and thus an id within
3190 the URL of "#index-Wformat". */
3191 "#index", cl_options[option_index].opt_text,
3192 NULL);
3193 else
3194 return NULL;
3195 }
3196
3197 #if CHECKING_P
3198
3199 namespace selftest {
3200
3201 /* Verify that get_option_html_page works as expected. */
3202
3203 static void
3204 test_get_option_html_page ()
3205 {
3206 ASSERT_STREQ (get_option_html_page (OPT_Wcpp), "gcc/Warning-Options.html");
3207 ASSERT_STREQ (get_option_html_page (OPT_Wanalyzer_double_free),
3208 "gcc/Static-Analyzer-Options.html");
3209 #ifdef CL_Fortran
3210 ASSERT_STREQ (get_option_html_page (OPT_Wline_truncation),
3211 "gfortran/Error-and-Warning-Options.html");
3212 #endif
3213 }
3214
3215 /* Run all of the selftests within this file. */
3216
3217 void
3218 opts_c_tests ()
3219 {
3220 test_get_option_html_page ();
3221 }
3222
3223 } // namespace selftest
3224
3225 #endif /* #if CHECKING_P */
3226