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