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