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