]> gcc.gnu.org Git - gcc.git/blame - gcc/opts.c
git://gcc.gnu.org / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* config/arm/arm.h (REG_CLASS_NAMES): Add missing comma.
[gcc.git] / gcc / opts.c
CommitLineData
2772ef3e 1/* Command line option handling.
b684a3df 2 Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
2772ef3e
NB		 3 Contributed by Neil Booth.
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 2, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING. If not, write to the Free
19Software Foundation, 59 Temple Place - Suite 330, Boston, MA
2002111-1307, USA. */
21
22#include "config.h"
23#include "system.h"
cf03fd63 24#include "intl.h"
2772ef3e
NB		 25#include "coretypes.h"
26#include "tm.h"
27#include "tree.h"
058de654
NB		 28#include "rtl.h"
29#include "ggc.h"
30#include "output.h"
2772ef3e
NB		 31#include "langhooks.h"
32#include "opts.h"
d7b42618
NB		 33#include "options.h"
34#include "flags.h"
35#include "toplev.h"
903caebf 36#include "params.h"
de32c0cb 37#include "diagnostic.h"
9756310a 38#include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
d6553b54 39#include "insn-attr.h" /* For INSN_SCHEDULING. */
2772ef3e 40
d185d268
NB		 41/* Value of the -G xx switch, and whether it was passed or not. */
42unsigned HOST_WIDE_INT g_switch_value;
43bool g_switch_set;
44
45/* True if we should exit after parsing options. */
46bool exit_after_options;
47
48/* If -version. */
49bool version_flag;
50
e01cc6dc
NB		 51/* Print various extra warnings. -W/-Wextra. */
52bool extra_warnings;
53
54/* Don't print warning messages. -w. */
55bool inhibit_warnings;
56
57/* Treat warnings as errors. -Werror. */
58bool warnings_are_errors;
59
60/* Warn if a function returns an aggregate, since there are often
61 incompatible calling conventions for doing this. */
62bool warn_aggregate_return;
63
64/* Nonzero means warn about pointer casts that increase the required
65 alignment of the target type (and might therefore lead to a crash
66 due to a misaligned access). */
67bool warn_cast_align;
68
69/* Nonzero means warn about uses of __attribute__((deprecated))
70 declarations. */
71bool warn_deprecated_decl = true;
72
73/* Warn when an optimization pass is disabled. */
74bool warn_disabled_optimization;
75
76/* Nonzero means warn if inline function is too large. */
77bool warn_inline;
78
79/* True to warn about any objects definitions whose size is larger
80 than N bytes. Also want about function definitions whose returned
81 values are larger than N bytes, where N is `larger_than_size'. */
82bool warn_larger_than;
83HOST_WIDE_INT larger_than_size;
84
85/* Warn about functions which might be candidates for attribute noreturn. */
86bool warn_missing_noreturn;
87
88/* True to warn about code which is never reached. */
89bool warn_notreached;
90
91/* Warn if packed attribute on struct is unnecessary and inefficient. */
92bool warn_packed;
93
94/* Warn when gcc pads a structure to an alignment boundary. */
95bool warn_padded;
96
97/* True means warn about all declarations which shadow others. */
98bool warn_shadow;
99
100/* Nonzero means warn about constructs which might not be
101 strict-aliasing safe. */
102bool warn_strict_aliasing;
103
104/* True to warn if a switch on an enum, that does not have a default
105 case, fails to have a case for every enum value. */
106bool warn_switch;
107
108/* Warn if a switch does not have a default case. */
109bool warn_switch_default;
110
111/* Warn if a switch on an enum fails to have a case for every enum
112 value (regardless of the presence or otherwise of a default case). */
113bool warn_switch_enum;
114
115/* Don't suppress warnings from system headers. -Wsystem-headers. */
116bool warn_system_headers;
117
118/* True to warn about variables used before they are initialized. */
119int warn_uninitialized;
120
121/* True to warn about unused variables, functions et.al. */
122bool warn_unused_function;
123bool warn_unused_label;
124bool warn_unused_parameter;
125bool warn_unused_variable;
126bool warn_unused_value;
127
903caebf
NB		 128/* Hack for cooperation between set_Wunused and set_Wextra. */
129static bool maybe_warn_unused_parameter;
130
df38ffef
NB		 131/* Type(s) of debugging information we are producing (if any). See
132 flags.h for the definitions of the different possible types of
133 debugging information. */
134enum debug_info_type write_symbols = NO_DEBUG;
135
136/* Level of debugging information we are producing. See flags.h for
137 the definitions of the different possible levels. */
138enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
139
140/* Nonzero means use GNU-only extensions in the generated symbolic
141 debugging information. Currently, this only has an effect when
142 write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
143bool use_gnu_debug_info_extensions;
144
2cc98056
NB		 145/* Columns of --help display. */
146static unsigned int columns = 80;
147
148/* What to print when a switch has no documentation. */
149static const char undocumented_msg[] = N_("This switch lacks documentation");
150
a8a5f53a
JH		 151/* Used for bookkeeping on whether user set these flags so
152 -fprofile-use/-fprofile-generate does not use them. */
153static bool profile_arc_flag_set, flag_profile_values_set;
154static bool flag_unroll_loops_set, flag_tracer_set;
155static bool flag_value_profile_transformations_set;
156static bool flag_peel_loops_set, flag_branch_probabilities_set;
157
59e4e217 158/* Input file names. */
40e941af
PB		 159const char **in_fnames;
160unsigned num_in_fnames;
161
35399bdc 162static size_t find_opt (const char *, int);
d7b42618 163static int common_handle_option (size_t scode, const char *arg, int value);
903caebf
NB		 164static void handle_param (const char *);
165static void set_Wextra (int);
b86f6cd9 166static unsigned int handle_option (const char **argv, unsigned int lang_mask);
f18754d6
NB		 167static char *write_langs (unsigned int lang_mask);
168static void complain_wrong_lang (const char *, const struct cl_option *,
169 unsigned int lang_mask);
b86f6cd9 170static void handle_options (unsigned int, const char **, unsigned int);
2cc98056 171static void wrap_help (const char *help, const char *item, unsigned int);
cf03fd63 172static void print_help (void);
2cc98056 173static void print_param_help (void);
72de27ea 174static void print_filtered_help (unsigned int flag);
2cc98056 175static unsigned int print_switch (const char *text, unsigned int indent);
df38ffef
NB		 176static void set_debug_level (enum debug_info_type type, int extended,
177 const char *arg);
2772ef3e
NB		 178
179/* Perform a binary search to find which option the command-line INPUT
9cd23ed2
NB		 180 matches. Returns its index in the option array, and N_OPTS
181 (cl_options_count) on failure.
182
183 This routine is quite subtle. A normal binary search is not good
184 enough because some options can be suffixed with an argument, and
185 multiple sub-matches can occur, e.g. input of "-pedantic" matching
186 the initial substring of "-pedantic-errors".
187
188 A more complicated example is -gstabs. It should match "-g" with
189 an argument of "stabs". Suppose, however, that the number and list
190 of switches are such that the binary search tests "-gen-decls"
191 before having tested "-g". This doesn't match, and as "-gen-decls"
192 is less than "-gstabs", it will become the lower bound of the
193 binary search range, and "-g" will never be seen. To resolve this
194 issue, opts.sh makes "-gen-decls" point, via the back_chain member,
195 to "-g" so that failed searches that end between "-gen-decls" and
196 the lexicographically subsequent switch know to go back and see if
197 "-g" causes a match (which it does in this example).
198
199 This search is done in such a way that the longest match for the
200 front end in question wins. If there is no match for the current
201 front end, the longest match for a different front end is returned
202 (or N_OPTS if none) and the caller emits an error message. */
35399bdc 203static size_t
2772ef3e
NB		 204find_opt (const char *input, int lang_mask)
205{
9cd23ed2
NB		 206 size_t mn, mx, md, opt_len;
207 size_t match_wrong_lang;
2772ef3e
NB		 208 int comp;
209
210 mn = 0;
35399bdc 211 mx = cl_options_count;
2772ef3e 212
9cd23ed2
NB		 213 /* Find mn such this lexicographical inequality holds:
214 cl_options[mn] <= input < cl_options[mn + 1]. */
215 while (mx - mn > 1)
2772ef3e
NB		 216 {
217 md = (mn + mx) / 2;
2772ef3e 218 opt_len = cl_options[md].opt_len;
cf03fd63 219 comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
2772ef3e
NB		 220
221 if (comp < 0)
222 mx = md;
2772ef3e 223 else
9cd23ed2
NB		 224 mn = md;
225 }
226
227 /* This is the switch that is the best match but for a different
228 front end, or cl_options_count if there is no match at all. */
229 match_wrong_lang = cl_options_count;
230
231 /* Backtrace the chain of possible matches, returning the longest
232 one, if any, that fits best. With current GCC switches, this
233 loop executes at most twice. */
234 do
235 {
236 const struct cl_option *opt = &cl_options[mn];
237
238 /* Is this switch a prefix of the input? */
cf03fd63 239 if (!strncmp (input, opt->opt_text + 1, opt->opt_len))
2772ef3e 240 {
9cd23ed2
NB		 241 /* If language is OK, and the match is exact or the switch
242 takes a joined argument, return it. */
243 if ((opt->flags & lang_mask)
244 && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
245 return mn;
246
247 /* If we haven't remembered a prior match, remember this
248 one. Any prior match is necessarily better. */
f18754d6 249 if (match_wrong_lang == cl_options_count)
9cd23ed2 250 match_wrong_lang = mn;
2772ef3e 251 }
9cd23ed2
NB		 252
253 /* Try the next possibility. This is cl_options_count if there
254 are no more. */
255 mn = opt->back_chain;
2772ef3e 256 }
9cd23ed2 257 while (mn != cl_options_count);
2772ef3e 258
9cd23ed2
NB		 259 /* Return the best wrong match, or cl_options_count if none. */
260 return match_wrong_lang;
2772ef3e
NB		 261}
262
e01cc6dc 263/* If ARG is a non-negative integer made up solely of digits, return its
7b086b11
NB		 264 value, otherwise return -1. */
265static int
266integral_argument (const char *arg)
267{
268 const char *p = arg;
269
270 while (*p && ISDIGIT (*p))
271 p++;
272
273 if (*p == '\0')
274 return atoi (arg);
275
276 return -1;
277}
278
f18754d6
NB		 279/* Return a malloced slash-separated list of languages in MASK. */
280static char *
281write_langs (unsigned int mask)
282{
283 unsigned int n = 0, len = 0;
284 const char *lang_name;
285 char *result;
286
287 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
288 if (mask & (1U << n))
289 len += strlen (lang_name) + 1;
290
291 result = xmalloc (len);
292 len = 0;
293 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
294 if (mask & (1U << n))
295 {
296 if (len)
297 result[len++] = '/';
298 strcpy (result + len, lang_name);
299 len += strlen (lang_name);
300 }
301
302 result[len] = 0;
303
304 return result;
305}
306
307/* Complain that switch OPT_INDEX does not apply to this front end. */
308static void
309complain_wrong_lang (const char *text, const struct cl_option *option,
310 unsigned int lang_mask)
311{
312 char *ok_langs, *bad_lang;
313
314 ok_langs = write_langs (option->flags);
315 bad_lang = write_langs (lang_mask);
316
317 /* Eventually this should become a hard error IMO. */
318 warning ("command line option \"%s\" is valid for %s but not for %s",
319 text, ok_langs, bad_lang);
320
321 free (ok_langs);
322 free (bad_lang);
323}
324
325/* Handle the switch beginning at ARGV for the language indicated by
326 LANG_MASK. Returns the number of switches consumed. */
327static unsigned int
b86f6cd9 328handle_option (const char **argv, unsigned int lang_mask)
2772ef3e
NB		 329{
330 size_t opt_index;
331 const char *opt, *arg = 0;
332 char *dup = 0;
7b086b11 333 int value = 1;
f18754d6 334 unsigned int result = 0;
2772ef3e
NB		 335 const struct cl_option *option;
336
2772ef3e
NB		 337 opt = argv[0];
338
cb66e385
NB		 339 /* Drop the "no-" from negative switches. */
340 if ((opt[1] == 'W' || opt[1] == 'f')
341 && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
2772ef3e 342 {
cb66e385
NB		 343 size_t len = strlen (opt) - 3;
344
345 dup = xmalloc (len + 1);
346 dup[0] = '-';
347 dup[1] = opt[1];
348 memcpy (dup + 2, opt + 5, len - 2 + 1);
349 opt = dup;
350 value = 0;
2772ef3e 351 }
2772ef3e 352
cb66e385
NB		 353 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON);
354 if (opt_index == cl_options_count)
355 goto done;
2772ef3e 356
cb66e385 357 option = &cl_options[opt_index];
2772ef3e 358
cb66e385
NB		 359 /* Reject negative form of switches that don't take negatives as
360 unrecognized. */
361 if (!value && (option->flags & CL_REJECT_NEGATIVE))
362 goto done;
2772ef3e 363
cb66e385
NB		 364 /* We've recognized this switch. */
365 result = 1;
2772ef3e 366
cb66e385
NB		 367 /* Sort out any argument the switch takes. */
368 if (option->flags & CL_JOINED)
369 {
370 /* Have arg point to the original switch. This is because
371 some code, such as disable_builtin_function, expects its
372 argument to be persistent until the program exits. */
373 arg = argv[0] + cl_options[opt_index].opt_len + 1;
374 if (!value)
375 arg += strlen ("no-");
376
377 if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
2772ef3e 378 {
cb66e385 379 if (option->flags & CL_SEPARATE)
2772ef3e 380 {
cb66e385
NB		 381 arg = argv[1];
382 result = 2;
2772ef3e 383 }
cb66e385
NB		 384 else
385 /* Missing argument. */
386 arg = NULL;
7b086b11 387 }
cb66e385
NB		 388 }
389 else if (option->flags & CL_SEPARATE)
390 {
391 arg = argv[1];
392 result = 2;
393 }
2772ef3e 394
cb66e385
NB		 395 /* Now we've swallowed any potential argument, complain if this
396 is a switch for a different front end. */
397 if (!(option->flags & (lang_mask | CL_COMMON)))
398 {
399 complain_wrong_lang (argv[0], option, lang_mask);
400 goto done;
401 }
f18754d6 402
cb66e385
NB		 403 if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
404 {
405 if (!(*lang_hooks.missing_argument) (opt, opt_index))
406 error ("missing argument to \"%s\"", opt);
407 goto done;
408 }
9eee5e72 409
cb66e385
NB		 410 /* If the switch takes an integer, convert it. */
411 if (arg && (option->flags & CL_UINTEGER))
412 {
413 value = integral_argument (arg);
414 if (value == -1)
7b086b11 415 {
cf03fd63 416 error ("argument to \"%s\" should be a non-negative integer",
cb66e385
NB		 417 option->opt_text);
418 goto done;
2772ef3e 419 }
cb66e385 420 }
2772ef3e 421
cb66e385
NB		 422 if (option->flags & lang_mask)
423 if ((*lang_hooks.handle_option) (opt_index, arg, value) == 0)
424 result = 0;
d7b42618 425
cb66e385
NB		 426 if (result && (option->flags & CL_COMMON))
427 if (common_handle_option (opt_index, arg, value) == 0)
428 result = 0;
2772ef3e
NB		 429
430 done:
431 if (dup)
432 free (dup);
433 return result;
434}
d7b42618 435
f18754d6
NB		 436/* Decode and handle the vector of command line options. LANG_MASK
437 contains has a single bit set representing the current
438 language. */
9756310a 439static void
b86f6cd9 440handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
f18754d6
NB		 441{
442 unsigned int n, i;
443
444 for (i = 1; i < argc; i += n)
445 {
cb66e385
NB		 446 const char *opt = argv[i];
447
448 /* Interpret "-" or a non-switch as a file name. */
449 if (opt[0] != '-' || opt[1] == '\0')
450 {
451 main_input_filename = opt;
40e941af 452 add_input_filename (opt);
cb66e385
NB		 453 n = 1;
454 continue;
455 }
456
f18754d6
NB		 457 n = handle_option (argv + i, lang_mask);
458
459 if (!n)
460 {
461 n = 1;
cb66e385 462 error ("unrecognized command line option \"%s\"", opt);
f18754d6
NB		 463 }
464 }
465}
466
40e941af
PB		 467/* Handle FILENAME from the command line. */
468void
469add_input_filename (const char *filename)
470{
471 num_in_fnames++;
472 in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0]));
473 in_fnames[num_in_fnames - 1] = filename;
474}
475
9756310a
NB		 476/* Parse command line options and set default flag values. Do minimal
477 options processing. */
478void
b86f6cd9 479decode_options (unsigned int argc, const char **argv)
9756310a 480{
b86f6cd9 481 unsigned int i, lang_mask;
9756310a
NB		 482
483 /* Perform language-specific options initialization. */
b86f6cd9 484 lang_mask = (*lang_hooks.init_options) (argc, argv);
9756310a 485
21ecc5a7
GDR		 486 lang_hooks.initialize_diagnostics (global_dc);
487
9756310a
NB		 488 /* Scan to see what optimization level has been specified. That will
489 determine the default value of many flags. */
490 for (i = 1; i < argc; i++)
491 {
492 if (!strcmp (argv[i], "-O"))
493 {
494 optimize = 1;
495 optimize_size = 0;
496 }
497 else if (argv[i][0] == '-' && argv[i][1] == 'O')
498 {
499 /* Handle -Os, -O2, -O3, -O69, ... */
b86f6cd9 500 const char *p = &argv[i][2];
9756310a
NB		 501
502 if ((p[0] == 's') && (p[1] == 0))
503 {
504 optimize_size = 1;
505
506 /* Optimizing for size forces optimize to be 2. */
507 optimize = 2;
508 }
509 else
510 {
511 const int optimize_val = read_integral_parameter (p, p - 2, -1);
512 if (optimize_val != -1)
513 {
514 optimize = optimize_val;
515 optimize_size = 0;
516 }
517 }
518 }
519 }
520
521 if (!optimize)
522 {
523 flag_merge_constants = 0;
524 }
525
526 if (optimize >= 1)
527 {
528 flag_defer_pop = 1;
529 flag_thread_jumps = 1;
530#ifdef DELAY_SLOTS
531 flag_delayed_branch = 1;
532#endif
533#ifdef CAN_DEBUG_WITHOUT_FP
534 flag_omit_frame_pointer = 1;
535#endif
536 flag_guess_branch_prob = 1;
537 flag_cprop_registers = 1;
538 flag_loop_optimize = 1;
9756310a
NB		 539 flag_if_conversion = 1;
540 flag_if_conversion2 = 1;
541 }
542
543 if (optimize >= 2)
544 {
b684a3df 545 flag_crossjumping = 1;
9756310a
NB		 546 flag_optimize_sibling_calls = 1;
547 flag_cse_follow_jumps = 1;
548 flag_cse_skip_blocks = 1;
549 flag_gcse = 1;
550 flag_expensive_optimizations = 1;
551 flag_strength_reduce = 1;
552 flag_rerun_cse_after_loop = 1;
553 flag_rerun_loop_opt = 1;
554 flag_caller_saves = 1;
555 flag_force_mem = 1;
556 flag_peephole2 = 1;
557#ifdef INSN_SCHEDULING
558 flag_schedule_insns = 1;
559 flag_schedule_insns_after_reload = 1;
560#endif
561 flag_regmove = 1;
562 flag_strict_aliasing = 1;
563 flag_delete_null_pointer_checks = 1;
564 flag_reorder_blocks = 1;
565 flag_reorder_functions = 1;
1f95c733 566 flag_unit_at_a_time = 1;
9756310a
NB		 567 }
568
569 if (optimize >= 3)
570 {
571 flag_inline_functions = 1;
572 flag_rename_registers = 1;
573 flag_unswitch_loops = 1;
62551c66 574 flag_web = 1;
9756310a
NB		 575 }
576
577 if (optimize < 2 || optimize_size)
578 {
579 align_loops = 1;
580 align_jumps = 1;
581 align_labels = 1;
582 align_functions = 1;
583
584 /* Don't reorder blocks when optimizing for size because extra
585 jump insns may be created; also barrier may create extra padding.
586
587 More correctly we should have a block reordering mode that tried
588 to minimize the combined size of all the jumps. This would more
589 or less automatically remove extra jumps, but would also try to
590 use more short jumps instead of long jumps. */
591 flag_reorder_blocks = 0;
592 }
593
594 /* Initialize whether `char' is signed. */
595 flag_signed_char = DEFAULT_SIGNED_CHAR;
596#ifdef DEFAULT_SHORT_ENUMS
597 /* Initialize how much space enums occupy, by default. */
598 flag_short_enums = DEFAULT_SHORT_ENUMS;
599#endif
600
601 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
602 modify it. */
603 target_flags = 0;
604 set_target_switch ("");
605
606 /* Unwind tables are always present in an ABI-conformant IA-64
607 object file, so the default should be ON. */
608#ifdef IA64_UNWIND_INFO
609 flag_unwind_tables = IA64_UNWIND_INFO;
610#endif
611
612#ifdef OPTIMIZATION_OPTIONS
613 /* Allow default optimizations to be specified on a per-machine basis. */
614 OPTIMIZATION_OPTIONS (optimize, optimize_size);
615#endif
616
617 handle_options (argc, argv, lang_mask);
618
619 if (flag_pie)
620 flag_pic = flag_pie;
621 if (flag_pic && !flag_pie)
622 flag_shlib = 1;
623
624 if (flag_no_inline == 2)
625 flag_no_inline = 0;
626 else
627 flag_really_no_inline = flag_no_inline;
628
629 /* Set flag_no_inline before the post_options () hook. The C front
630 ends use it to determine tree inlining defaults. FIXME: such
631 code should be lang-independent when all front ends use tree
632 inlining, in which case it, and this condition, should be moved
633 to the top of process_options() instead. */
634 if (optimize == 0)
635 {
636 /* Inlining does not work if not optimizing,
637 so force it not to be done. */
638 flag_no_inline = 1;
639 warn_inline = 0;
640
641 /* The c_decode_option function and decode_option hook set
642 this to `2' if -Wall is used, so we can avoid giving out
643 lots of errors for people who don't realize what -Wall does. */
644 if (warn_uninitialized == 1)
645 warning ("-Wuninitialized is not supported without -O");
646 }
647
648 if (flag_really_no_inline == 2)
649 flag_really_no_inline = flag_no_inline;
650}
651
d7b42618
NB		 652/* Handle target- and language-independent options. Return zero to
653 generate an "unknown option" message. */
654static int
655common_handle_option (size_t scode, const char *arg,
656 int value ATTRIBUTE_UNUSED)
657{
d7b42618
NB		 658 enum opt_code code = (enum opt_code) scode;
659
d7b42618
NB		 660 switch (code)
661 {
662 default:
663 abort ();
664
d185d268 665 case OPT__help:
cf03fd63 666 print_help ();
d185d268
NB		 667 exit_after_options = true;
668 break;
669
903caebf
NB		 670 case OPT__param:
671 handle_param (arg);
672 break;
673
d185d268
NB		 674 case OPT__target_help:
675 display_target_options ();
676 exit_after_options = true;
677 break;
678
679 case OPT__version:
680 print_version (stderr, "");
681 exit_after_options = true;
682 break;
683
684 case OPT_G:
7b086b11 685 g_switch_value = value;
d185d268
NB		 686 g_switch_set = true;
687 break;
688
903caebf
NB		 689 case OPT_O:
690 case OPT_Os:
691 /* Currently handled in a prescan. */
692 break;
693
694 case OPT_W:
695 /* For backward compatibility, -W is the same as -Wextra. */
696 set_Wextra (value);
697 break;
698
e01cc6dc
NB		 699 case OPT_Waggregate_return:
700 warn_aggregate_return = value;
701 break;
702
703 case OPT_Wcast_align:
704 warn_cast_align = value;
705 break;
706
707 case OPT_Wdeprecated_declarations:
708 warn_deprecated_decl = value;
0bd95603 709 break;
e01cc6dc
NB		 710
711 case OPT_Wdisabled_optimization:
712 warn_disabled_optimization = value;
713 break;
714
715 case OPT_Werror:
716 warnings_are_errors = value;
717 break;
718
903caebf
NB		 719 case OPT_Wextra:
720 set_Wextra (value);
721 break;
722
e01cc6dc
NB		 723 case OPT_Winline:
724 warn_inline = value;
725 break;
726
727 case OPT_Wlarger_than_:
728 larger_than_size = value;
729 warn_larger_than = value != -1;
730 break;
731
732 case OPT_Wmissing_noreturn:
733 warn_missing_noreturn = value;
734 break;
735
736 case OPT_Wpacked:
737 warn_packed = value;
738 break;
739
740 case OPT_Wpadded:
741 warn_padded = value;
742 break;
743
744 case OPT_Wshadow:
745 warn_shadow = value;
746 break;
747
748 case OPT_Wstrict_aliasing:
749 warn_strict_aliasing = value;
750 break;
751
752 case OPT_Wswitch:
753 warn_switch = value;
754 break;
755
756 case OPT_Wswitch_default:
757 warn_switch_default = value;
758 break;
759
760 case OPT_Wswitch_enum:
761 warn_switch_enum = value;
762 break;
763
764 case OPT_Wsystem_headers:
765 warn_system_headers = value;
766 break;
767
768 case OPT_Wuninitialized:
769 warn_uninitialized = value;
770 break;
771
772 case OPT_Wunreachable_code:
773 warn_notreached = value;
774 break;
775
903caebf
NB		 776 case OPT_Wunused:
777 set_Wunused (value);
778 break;
779
e01cc6dc
NB		 780 case OPT_Wunused_function:
781 warn_unused_function = value;
782 break;
783
784 case OPT_Wunused_label:
785 warn_unused_label = value;
786 break;
787
788 case OPT_Wunused_parameter:
789 warn_unused_parameter = value;
790 break;
791
792 case OPT_Wunused_value:
793 warn_unused_value = value;
794 break;
795
796 case OPT_Wunused_variable:
797 warn_unused_variable = value;
798 break;
799
d185d268
NB		 800 case OPT_aux_info:
801 case OPT_aux_info_:
802 aux_info_file_name = arg;
803 flag_gen_aux_info = 1;
804 break;
805
806 case OPT_auxbase:
807 aux_base_name = arg;
808 break;
809
810 case OPT_auxbase_strip:
811 {
812 char *tmp = xstrdup (arg);
813 strip_off_ending (tmp, strlen (tmp));
814 if (tmp[0])
815 aux_base_name = tmp;
816 }
817 break;
818
819 case OPT_d:
820 decode_d_option (arg);
821 break;
822
823 case OPT_dumpbase:
824 dump_base_name = arg;
825 break;
826
6ff3a151
NB		 827 case OPT_fPIC:
828 flag_pic = value + value;
829 break;
830
831 case OPT_fPIE:
832 flag_pie = value + value;
833 break;
834
835 case OPT_falign_functions:
5e14ae7e 836 align_functions = !value;
058de654
NB		 837 break;
838
0fcd5dda
NB		 839 case OPT_falign_functions_:
840 align_functions = value;
841 break;
842
6ff3a151 843 case OPT_falign_jumps:
5e14ae7e 844 align_jumps = !value;
058de654
NB		 845 break;
846
0fcd5dda
NB		 847 case OPT_falign_jumps_:
848 align_jumps = value;
849 break;
850
6ff3a151 851 case OPT_falign_labels:
5e14ae7e 852 align_labels = !value;
058de654
NB		 853 break;
854
0fcd5dda
NB		 855 case OPT_falign_labels_:
856 align_labels = value;
857 break;
858
6ff3a151 859 case OPT_falign_loops:
5e14ae7e 860 align_loops = !value;
058de654
NB		 861 break;
862
0fcd5dda
NB		 863 case OPT_falign_loops_:
864 align_loops = value;
865 break;
866
6ff3a151
NB		 867 case OPT_fargument_alias:
868 flag_argument_noalias = !value;
869 break;
870
871 case OPT_fargument_noalias:
872 flag_argument_noalias = value;
873 break;
874
875 case OPT_fargument_noalias_global:
876 flag_argument_noalias = value + value;
877 break;
878
879 case OPT_fasynchronous_unwind_tables:
880 flag_asynchronous_unwind_tables = value;
881 break;
882
883 case OPT_fbounds_check:
884 flag_bounds_check = value;
885 break;
886
887 case OPT_fbranch_count_reg:
888 flag_branch_on_count_reg = value;
889 break;
890
891 case OPT_fbranch_probabilities:
a8a5f53a 892 flag_branch_probabilities_set = true;
6ff3a151
NB		 893 flag_branch_probabilities = value;
894 break;
895
de32c0cb
NB		 896 case OPT_fbranch_target_load_optimize:
897 flag_branch_target_load_optimize = value;
898 break;
899
900 case OPT_fbranch_target_load_optimize2:
901 flag_branch_target_load_optimize2 = value;
902 break;
903
1194fc79
R		 904 case OPT_fbtr_bb_exclusive:
905 flag_btr_bb_exclusive = value;
906 break;
907
058de654
NB		 908 case OPT_fcall_used_:
909 fix_register (arg, 0, 1);
910 break;
911
912 case OPT_fcall_saved_:
913 fix_register (arg, 0, 0);
914 break;
915
de32c0cb
NB		 916 case OPT_fcaller_saves:
917 flag_caller_saves = value;
918 break;
919
6ff3a151
NB		 920 case OPT_fcommon:
921 flag_no_common = !value;
922 break;
923
924 case OPT_fcprop_registers:
925 flag_cprop_registers = value;
926 break;
927
de32c0cb
NB		 928 case OPT_fcrossjumping:
929 flag_crossjumping = value;
930 break;
931
932 case OPT_fcse_follow_jumps:
933 flag_cse_follow_jumps = value;
934 break;
935
936 case OPT_fcse_skip_blocks:
937 flag_cse_skip_blocks = value;
938 break;
939
6ff3a151
NB		 940 case OPT_fdata_sections:
941 flag_data_sections = value;
942 break;
943
de32c0cb
NB		 944 case OPT_fdefer_pop:
945 flag_defer_pop = value;
946 break;
947
948 case OPT_fdelayed_branch:
949 flag_delayed_branch = value;
950 break;
951
952 case OPT_fdelete_null_pointer_checks:
953 flag_delete_null_pointer_checks = value;
954 break;
955
956 case OPT_fdiagnostics_show_location_:
957 if (!strcmp (arg, "once"))
958 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
959 else if (!strcmp (arg, "every-line"))
960 diagnostic_prefixing_rule (global_dc)
961 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
962 else
963 return 0;
964 break;
965
6ff3a151
NB		 966 case OPT_fdump_unnumbered:
967 flag_dump_unnumbered = value;
968 break;
969
de32c0cb
NB		 970 case OPT_feliminate_dwarf2_dups:
971 flag_eliminate_dwarf2_dups = value;
972 break;
973
974 case OPT_feliminate_unused_debug_types:
975 flag_eliminate_unused_debug_types = value;
976 break;
977
6a08f7b3
DP		 978 case OPT_feliminate_unused_debug_symbols:
979 flag_debug_only_used_symbols = value;
980 break;
981
6ff3a151
NB		 982 case OPT_fexceptions:
983 flag_exceptions = value;
984 break;
985
de32c0cb
NB		 986 case OPT_fexpensive_optimizations:
987 flag_expensive_optimizations = value;
988 break;
989
058de654
NB		 990 case OPT_ffast_math:
991 set_fast_math_flags (value);
992 break;
993
6ff3a151
NB		 994 case OPT_ffinite_math_only:
995 flag_finite_math_only = value;
996 break;
997
058de654
NB		 998 case OPT_ffixed_:
999 fix_register (arg, 1, 1);
1000 break;
1001
de32c0cb
NB		 1002 case OPT_ffunction_cse:
1003 flag_no_function_cse = !value;
1004 break;
1005
1006 case OPT_ffloat_store:
1007 flag_float_store = value;
1008 break;
1009
1010 case OPT_fforce_addr:
1011 flag_force_addr = value;
1012 break;
1013
1014 case OPT_fforce_mem:
1015 flag_force_mem = value;
1016 break;
1017
6ff3a151
NB		 1018 case OPT_ffunction_sections:
1019 flag_function_sections = value;
1020 break;
1021
de32c0cb
NB		 1022 case OPT_fgcse:
1023 flag_gcse = value;
1024 break;
1025
1026 case OPT_fgcse_lm:
1027 flag_gcse_lm = value;
1028 break;
1029
1030 case OPT_fgcse_sm:
1031 flag_gcse_sm = value;
1032 break;
1033
f5f2e3cd
MH		 1034 case OPT_fgcse_las:
1035 flag_gcse_las = value;
1036 break;
1037
6ff3a151
NB		 1038 case OPT_fguess_branch_probability:
1039 flag_guess_branch_prob = value;
1040 break;
1041
1042 case OPT_fident:
1043 flag_no_ident = !value;
1044 break;
1045
de32c0cb
NB		 1046 case OPT_fif_conversion:
1047 flag_if_conversion = value;
1048 break;
1049
1050 case OPT_fif_conversion2:
1051 flag_if_conversion2 = value;
1052 break;
1053
6ff3a151
NB		 1054 case OPT_finhibit_size_directive:
1055 flag_inhibit_size_directive = value;
1056 break;
1057
de32c0cb
NB		 1058 case OPT_finline:
1059 flag_no_inline = !value;
1060 break;
1061
1062 case OPT_finline_functions:
1063 flag_inline_functions = value;
1064 break;
1065
d302c9d6
NB		 1066 case OPT_finline_limit_:
1067 case OPT_finline_limit_eq:
d302c9d6
NB		 1068 set_param_value ("max-inline-insns-single", value / 2);
1069 set_param_value ("max-inline-insns-auto", value / 2);
1070 set_param_value ("max-inline-insns-rtl", value);
d302c9d6
NB		 1071 break;
1072
6ff3a151
NB		 1073 case OPT_finstrument_functions:
1074 flag_instrument_function_entry_exit = value;
1075 break;
1076
de32c0cb
NB		 1077 case OPT_fkeep_inline_functions:
1078 flag_keep_inline_functions =value;
1079 break;
1080
1081 case OPT_fkeep_static_consts:
1082 flag_keep_static_consts = value;
1083 break;
1084
6ff3a151
NB		 1085 case OPT_fleading_underscore:
1086 flag_leading_underscore = value;
1087 break;
1088
de32c0cb
NB		 1089 case OPT_floop_optimize:
1090 flag_loop_optimize = value;
1091 break;
1092
6ff3a151
NB		 1093 case OPT_fmath_errno:
1094 flag_errno_math = value;
1095 break;
1096
1097 case OPT_fmem_report:
1098 mem_report = value;
1099 break;
1100
1101 case OPT_fmerge_all_constants:
1102 flag_merge_constants = value + value;
1103 break;
1104
1105 case OPT_fmerge_constants:
1106 flag_merge_constants = value;
1107 break;
1108
de32c0cb 1109 case OPT_fmessage_length_:
b6fe0bb8 1110 pp_set_line_maximum_length (global_dc->printer, value);
de32c0cb
NB		 1111 break;
1112
1113 case OPT_fmove_all_movables:
1114 flag_move_all_movables = value;
1115 break;
1116
6ff3a151
NB		 1117 case OPT_fnew_ra:
1118 flag_new_regalloc = value;
1119 break;
1120
1121 case OPT_fnon_call_exceptions:
1122 flag_non_call_exceptions = value;
1123 break;
1124
de32c0cb
NB		 1125 case OPT_fold_unroll_all_loops:
1126 flag_old_unroll_all_loops = value;
1127 break;
1128
1129 case OPT_fold_unroll_loops:
1130 flag_old_unroll_loops = value;
1131 break;
1132
1133 case OPT_fomit_frame_pointer:
1134 flag_omit_frame_pointer = value;
1135 break;
1136
6ff3a151
NB		 1137 case OPT_foptimize_register_move:
1138 flag_regmove = value;
1139 break;
1140
de32c0cb
NB		 1141 case OPT_foptimize_sibling_calls:
1142 flag_optimize_sibling_calls = value;
1143 break;
1144
6ff3a151
NB		 1145 case OPT_fpack_struct:
1146 flag_pack_struct = value;
1147 break;
1148
de32c0cb 1149 case OPT_fpeel_loops:
a8a5f53a 1150 flag_peel_loops_set = true;
de32c0cb
NB		 1151 flag_peel_loops = value;
1152 break;
1153
1154 case OPT_fpcc_struct_return:
1155 flag_pcc_struct_return = value;
1156 break;
1157
1158 case OPT_fpeephole:
1159 flag_no_peephole = !value;
1160 break;
1161
6ff3a151
NB		 1162 case OPT_fpeephole2:
1163 flag_peephole2 = value;
1164 break;
1165
1166 case OPT_fpic:
1167 flag_pic = value;
1168 break;
1169
1170 case OPT_fpie:
1171 flag_pie = value;
1172 break;
1173
de32c0cb
NB		 1174 case OPT_fprefetch_loop_arrays:
1175 flag_prefetch_loop_arrays = value;
1176 break;
1177
6ff3a151
NB		 1178 case OPT_fprofile:
1179 profile_flag = value;
1180 break;
1181
1182 case OPT_fprofile_arcs:
a8a5f53a 1183 profile_arc_flag_set = true;
6ff3a151
NB		 1184 profile_arc_flag = value;
1185 break;
1186
a8a5f53a
JH		 1187 case OPT_fprofile_use:
1188 if (!flag_branch_probabilities_set)
1189 flag_branch_probabilities = value;
1190 if (!flag_profile_values_set)
1191 flag_profile_values = value;
1192 if (!flag_unroll_loops_set)
1193 flag_unroll_loops = value;
1194 if (!flag_peel_loops_set)
1195 flag_peel_loops = value;
1196 if (!flag_tracer_set)
1197 flag_tracer = value;
1198 if (!flag_value_profile_transformations_set)
1199 flag_value_profile_transformations = value;
1200 break;
1201
1202 case OPT_fprofile_generate:
1203 if (!profile_arc_flag_set)
1204 profile_arc_flag = value;
1205 if (!flag_profile_values_set)
1206 flag_profile_values = value;
1207 if (!flag_value_profile_transformations_set)
1208 flag_value_profile_transformations = value;
1209 break;
1210
fca9dc00 1211 case OPT_fprofile_values:
a8a5f53a 1212 flag_profile_values_set = true;
fca9dc00
ZD		 1213 flag_profile_values = value;
1214 break;
1215
1216 case OPT_fvpt:
a8a5f53a 1217 flag_value_profile_transformations_set = value;
fca9dc00
ZD		 1218 flag_value_profile_transformations = value;
1219 break;
1220
de32c0cb
NB		 1221 case OPT_frandom_seed:
1222 /* The real switch is -fno-random-seed. */
1223 if (value)
1224 return 0;
1225 flag_random_seed = NULL;
1226 break;
1227
1228 case OPT_frandom_seed_:
1229 flag_random_seed = arg;
1230 break;
1231
1232 case OPT_freduce_all_givs:
1233 flag_reduce_all_givs = value;
1234 break;
1235
1236 case OPT_freg_struct_return:
1237 flag_pcc_struct_return = !value;
1238 break;
1239
6ff3a151
NB		 1240 case OPT_fregmove:
1241 flag_regmove = value;
1242 break;
1243
1244 case OPT_frename_registers:
1245 flag_rename_registers = value;
1246 break;
1247
1248 case OPT_freorder_blocks:
1249 flag_reorder_blocks = value;
1250 break;
1251
1252 case OPT_freorder_functions:
1253 flag_reorder_functions = value;
1254 break;
1255
de32c0cb
NB		 1256 case OPT_frerun_cse_after_loop:
1257 flag_rerun_cse_after_loop = value;
1258 break;
1259
1260 case OPT_frerun_loop_opt:
1261 flag_rerun_loop_opt = value;
1262 break;
1263
039c3d42
RS		 1264 case OPT_frounding_math:
1265 flag_rounding_math = value;
1266 break;
1267
6ff3a151 1268 case OPT_fsched_interblock:
039c3d42 1269 flag_schedule_interblock = value;
6ff3a151
NB		 1270 break;
1271
1272 case OPT_fsched_spec:
1273 flag_schedule_speculative = value;
1274 break;
1275
1276 case OPT_fsched_spec_load:
1277 flag_schedule_speculative_load = value;
1278 break;
1279
1280 case OPT_fsched_spec_load_dangerous:
1281 flag_schedule_speculative_load_dangerous = value;
1282 break;
1283
de32c0cb
NB		 1284 case OPT_fsched_verbose_:
1285#ifdef INSN_SCHEDULING
1286 fix_sched_param ("verbose", arg);
1287 break;
1288#else
1289 return 0;
1290#endif
1291
6ff3a151
NB		 1292 case OPT_fsched2_use_superblocks:
1293 flag_sched2_use_superblocks = value;
1294 break;
1295
1296 case OPT_fsched2_use_traces:
1297 flag_sched2_use_traces = value;
1298 break;
1299
de32c0cb
NB		 1300 case OPT_fschedule_insns:
1301 flag_schedule_insns = value;
1302 break;
1303
1304 case OPT_fschedule_insns2:
1305 flag_schedule_insns_after_reload = value;
1306 break;
1307
569fa502
DN		 1308 case OPT_fsched_stalled_insns:
1309 flag_sched_stalled_insns = value;
1310 break;
1311
1312 case OPT_fsched_stalled_insns_:
1313 flag_sched_stalled_insns = value;
1314 if (flag_sched_stalled_insns == 0)
1315 flag_sched_stalled_insns = -1;
1316 break;
1317
1318 case OPT_fsched_stalled_insns_dep:
1319 flag_sched_stalled_insns_dep = 1;
1320 break;
1321
1322 case OPT_fsched_stalled_insns_dep_:
1323 flag_sched_stalled_insns_dep = value;
1324 break;
1325
de32c0cb
NB		 1326 case OPT_fshared_data:
1327 flag_shared_data = value;
1328 break;
1329
6ff3a151
NB		 1330 case OPT_fsignaling_nans:
1331 flag_signaling_nans = value;
1332 break;
1333
1334 case OPT_fsingle_precision_constant:
1335 flag_single_precision_constant = value;
1336 break;
1337
6ff3a151
NB		 1338 case OPT_fstack_check:
1339 flag_stack_check = value;
1340 break;
1341
de32c0cb
NB		 1342 case OPT_fstack_limit:
1343 /* The real switch is -fno-stack-limit. */
1344 if (value)
1345 return 0;
1346 stack_limit_rtx = NULL_RTX;
1347 break;
1348
058de654
NB		 1349 case OPT_fstack_limit_register_:
1350 {
1351 int reg = decode_reg_name (arg);
1352 if (reg < 0)
1353 error ("unrecognized register name \"%s\"", arg);
1354 else
1355 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1356 }
1357 break;
1358
1359 case OPT_fstack_limit_symbol_:
1360 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1361 break;
1362
de32c0cb
NB		 1363 case OPT_fstrength_reduce:
1364 flag_strength_reduce = value;
1365 break;
1366
6ff3a151
NB		 1367 case OPT_fstrict_aliasing:
1368 flag_strict_aliasing = value;
1369 break;
1370
de32c0cb
NB		 1371 case OPT_fsyntax_only:
1372 flag_syntax_only = value;
1373 break;
1374
6ff3a151
NB		 1375 case OPT_ftest_coverage:
1376 flag_test_coverage = value;
1377 break;
1378
de32c0cb
NB		 1379 case OPT_fthread_jumps:
1380 flag_thread_jumps = value;
1381 break;
1382
6ff3a151
NB		 1383 case OPT_ftime_report:
1384 time_report = value;
0bd95603 1385 break;
6ff3a151 1386
058de654
NB		 1387 case OPT_ftls_model_:
1388 if (!strcmp (arg, "global-dynamic"))
1389 flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1390 else if (!strcmp (arg, "local-dynamic"))
1391 flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1392 else if (!strcmp (arg, "initial-exec"))
1393 flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1394 else if (!strcmp (arg, "local-exec"))
1395 flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1396 else
1397 warning ("unknown tls-model \"%s\"", arg);
1398 break;
1399
de32c0cb 1400 case OPT_ftracer:
a8a5f53a 1401 flag_tracer_set = true;
de32c0cb
NB		 1402 flag_tracer = value;
1403 break;
1404
6ff3a151
NB		 1405 case OPT_ftrapping_math:
1406 flag_trapping_math = value;
1407 break;
1408
1409 case OPT_ftrapv:
1410 flag_trapv = value;
1411 break;
1412
de32c0cb
NB		 1413 case OPT_funit_at_a_time:
1414 flag_unit_at_a_time = value;
1415 break;
1416
1417 case OPT_funroll_all_loops:
1418 flag_unroll_all_loops = value;
1419 break;
1420
1421 case OPT_funroll_loops:
a8a5f53a 1422 flag_unroll_loops_set = true;
de32c0cb
NB		 1423 flag_unroll_loops = value;
1424 break;
1425
6ff3a151
NB		 1426 case OPT_funsafe_math_optimizations:
1427 flag_unsafe_math_optimizations = value;
1428 break;
1429
de32c0cb
NB		 1430 case OPT_funswitch_loops:
1431 flag_unswitch_loops = value;
1432 break;
1433
6ff3a151
NB		 1434 case OPT_funwind_tables:
1435 flag_unwind_tables = value;
1436 break;
1437
1438 case OPT_fverbose_asm:
1439 flag_verbose_asm = value;
1440 break;
7260e9a0
JH		 1441
1442 case OPT_fweb:
1443 flag_web = value;
1444 break;
6ff3a151
NB		 1445
1446 case OPT_fwrapv:
1447 flag_wrapv = value;
1448 break;
1449
de32c0cb
NB		 1450 case OPT_fwritable_strings:
1451 flag_writable_strings = value;
1452 break;
1453
6ff3a151
NB		 1454 case OPT_fzero_initialized_in_bss:
1455 flag_zero_initialized_in_bss = value;
1456 break;
1457
e01cc6dc 1458 case OPT_g:
df38ffef
NB		 1459 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
1460 break;
1461
1462 case OPT_gcoff:
1463 set_debug_level (SDB_DEBUG, false, arg);
1464 break;
1465
df38ffef
NB		 1466 case OPT_gdwarf_2:
1467 set_debug_level (DWARF2_DEBUG, false, arg);
1468 break;
1469
1470 case OPT_ggdb:
1471 set_debug_level (NO_DEBUG, 2, arg);
1472 break;
1473
1474 case OPT_gstabs:
1475 case OPT_gstabs_:
1476 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
1477 break;
1478
1479 case OPT_gvms:
1480 set_debug_level (VMS_DEBUG, false, arg);
1481 break;
1482
1483 case OPT_gxcoff:
1484 case OPT_gxcoff_:
1485 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
e01cc6dc
NB		 1486 break;
1487
903caebf
NB		 1488 case OPT_m:
1489 set_target_switch (arg);
1490 break;
1491
d185d268
NB		 1492 case OPT_o:
1493 asm_file_name = arg;
1494 break;
1495
1496 case OPT_p:
1497 profile_flag = 1;
1498 break;
1499
1500 case OPT_pedantic:
1501 pedantic = 1;
1502 break;
1503
1504 case OPT_pedantic_errors:
1505 flag_pedantic_errors = pedantic = 1;
1506 break;
1507
d7b42618
NB		 1508 case OPT_quiet:
1509 quiet_flag = 1;
1510 break;
d185d268
NB		 1511
1512 case OPT_version:
1513 version_flag = 1;
1514 break;
1515
1516 case OPT_w:
e01cc6dc 1517 inhibit_warnings = true;
d185d268 1518 break;
d7b42618
NB		 1519 }
1520
1521 return 1;
1522}
903caebf
NB		 1523
1524/* Handle --param NAME=VALUE. */
1525static void
1526handle_param (const char *carg)
1527{
1528 char *equal, *arg;
1529 int value;
1530
1531 arg = xstrdup (carg);
1532 equal = strchr (arg, '=');
1533 if (!equal)
1534 error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1535 else
1536 {
1537 value = integral_argument (equal + 1);
1538 if (value == -1)
1539 error ("invalid --param value `%s'", equal + 1);
1540 else
1541 {
1542 *equal = '\0';
1543 set_param_value (arg, value);
1544 }
1545 }
1546
1547 free (arg);
1548}
1549
1550/* Handle -W and -Wextra. */
1551static void
1552set_Wextra (int setting)
1553{
1554 extra_warnings = setting;
1555 warn_unused_value = setting;
1556 warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1557
1558 /* We save the value of warn_uninitialized, since if they put
1559 -Wuninitialized on the command line, we need to generate a
1560 warning about not using it without also specifying -O. */
1561 if (setting == 0)
1562 warn_uninitialized = 0;
1563 else if (warn_uninitialized != 1)
1564 warn_uninitialized = 2;
1565}
1566
1567/* Initialize unused warning flags. */
1568void
1569set_Wunused (int setting)
1570{
1571 warn_unused_function = setting;
1572 warn_unused_label = setting;
1573 /* Unused function parameter warnings are reported when either
1574 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1575 Thus, if -Wextra has already been seen, set warn_unused_parameter;
1576 otherwise set maybe_warn_extra_parameter, which will be picked up
1577 by set_Wextra. */
1578 maybe_warn_unused_parameter = setting;
1579 warn_unused_parameter = (setting && extra_warnings);
1580 warn_unused_variable = setting;
1581 warn_unused_value = setting;
1582}
058de654
NB		 1583
1584/* The following routines are useful in setting all the flags that
1585 -ffast-math and -fno-fast-math imply. */
1586void
1587set_fast_math_flags (int set)
1588{
1589 flag_trapping_math = !set;
1590 flag_unsafe_math_optimizations = set;
1591 flag_finite_math_only = set;
1592 flag_errno_math = !set;
1593 if (set)
039c3d42
RS		 1594 {
1595 flag_signaling_nans = 0;
1596 flag_rounding_math = 0;
1597 }
058de654
NB		 1598}
1599
1600/* Return true iff flags are set as if -ffast-math. */
1601bool
1602fast_math_flags_set_p (void)
1603{
1604 return (!flag_trapping_math
1605 && flag_unsafe_math_optimizations
1606 && flag_finite_math_only
1607 && !flag_errno_math);
1608}
cf03fd63 1609
df38ffef
NB		 1610/* Handle a debug output -g switch. EXTENDED is true or false to support
1611 extended output (2 is special and means "-ggdb" was given). */
1612static void
1613set_debug_level (enum debug_info_type type, int extended, const char *arg)
1614{
1615 static bool type_explicit;
1616
1617 use_gnu_debug_info_extensions = extended;
1618
1619 if (type == NO_DEBUG)
1620 {
1621 if (write_symbols == NO_DEBUG)
1622 {
1623 write_symbols = PREFERRED_DEBUGGING_TYPE;
1624
1625 if (extended == 2)
1626 {
1627#ifdef DWARF2_DEBUGGING_INFO
1628 write_symbols = DWARF2_DEBUG;
1629#elif defined DBX_DEBUGGING_INFO
1630 write_symbols = DBX_DEBUG;
1631#endif
1632 }
1633
1634 if (write_symbols == NO_DEBUG)
1635 warning ("target system does not support debug output");
1636 }
1637 }
1638 else
1639 {
1640 /* Does it conflict with an already selected type? */
1641 if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1642 error ("debug format \"%s\" conflicts with prior selection",
1643 debug_type_names[type]);
1644 write_symbols = type;
1645 type_explicit = true;
1646 }
1647
1648 /* A debug flag without a level defaults to level 2. */
1649 if (*arg == '\0')
1650 {
1651 if (!debug_info_level)
1652 debug_info_level = 2;
1653 }
1654 else
1655 {
1656 debug_info_level = integral_argument (arg);
1657 if (debug_info_level == (unsigned int) -1)
1658 error ("unrecognised debug output level \"%s\"", arg);
1659 else if (debug_info_level > 3)
1660 error ("debug output level %s is too high", arg);
1661 }
1662}
1663
cf03fd63
NB		 1664/* Output --help text. */
1665static void
1666print_help (void)
72de27ea
NB		 1667{
1668 size_t i;
2cc98056
NB		 1669 const char *p;
1670
1671 GET_ENVIRONMENT (p, "COLUMNS");
1672 if (p)
1673 {
1674 int value = atoi (p);
1675 if (value > 0)
1676 columns = value;
1677 }
72de27ea
NB		 1678
1679 puts (_("The following options are language-independent:\n"));
1680
1681 print_filtered_help (CL_COMMON);
2cc98056 1682 print_param_help ();
72de27ea
NB		 1683
1684 for (i = 0; lang_names[i]; i++)
1685 {
2cc98056 1686 printf (_("The %s front end recognizes the following options:\n\n"),
72de27ea
NB		 1687 lang_names[i]);
1688 print_filtered_help (1U << i);
1689 }
1690
df38ffef 1691 display_target_options ();
72de27ea
NB		 1692}
1693
2cc98056
NB		 1694/* Print the help for --param. */
1695static void
1696print_param_help (void)
1697{
1698 size_t i;
1699
1700 puts (_("The --param option recognizes the following as parameters:\n"));
1701
1702 for (i = 0; i < LAST_PARAM; i++)
1703 {
1704 const char *help = compiler_params[i].help;
1705 const char *param = compiler_params[i].option;
1706
1707 if (help == NULL || *help == '\0')
1708 help = undocumented_msg;
1709
1710 /* Get the translation. */
1711 help = _(help);
1712
1713 wrap_help (help, param, strlen (param));
1714 }
1715
1716 putchar ('\n');
1717}
1718
72de27ea
NB		 1719/* Print help for a specific front-end, etc. */
1720static void
1721print_filtered_help (unsigned int flag)
cf03fd63 1722{
2cc98056
NB		 1723 unsigned int i, len, filter, indent = 0;
1724 bool duplicates = false;
1725 const char *help, *opt, *tab;
1726 static char *printed;
1727
1728 if (flag == CL_COMMON)
1729 {
1730 filter = flag;
1731 if (!printed)
1732 printed = xmalloc (cl_options_count);
1733 memset (printed, 0, cl_options_count);
1734 }
1735 else
1736 {
1737 /* Don't print COMMON options twice. */
1738 filter = flag | CL_COMMON;
cf03fd63 1739
2cc98056
NB		 1740 for (i = 0; i < cl_options_count; i++)
1741 {
1742 if ((cl_options[i].flags & filter) != flag)
1743 continue;
1744
1745 /* Skip help for internal switches. */
1746 if (cl_options[i].flags & CL_UNDOCUMENTED)
1747 continue;
1748
1749 /* Skip switches that have already been printed, mark them to be
1750 listed later. */
1751 if (printed[i])
1752 {
1753 duplicates = true;
1754 indent = print_switch (cl_options[i].opt_text, indent);
1755 }
1756 }
1757
1758 if (duplicates)
1759 {
1760 putchar ('\n');
1761 putchar ('\n');
1762 }
1763 }
cf03fd63
NB		 1764
1765 for (i = 0; i < cl_options_count; i++)
1766 {
72de27ea
NB		 1767 if ((cl_options[i].flags & filter) != flag)
1768 continue;
1769
f2ac9964
NB		 1770 /* Skip help for internal switches. */
1771 if (cl_options[i].flags & CL_UNDOCUMENTED)
1772 continue;
1773
2cc98056
NB		 1774 /* Skip switches that have already been printed. */
1775 if (printed[i])
1776 continue;
1777
1778 printed[i] = true;
1779
72de27ea 1780 help = cl_options[i].help;
cf03fd63 1781 if (!help)
2cc98056 1782 help = undocumented_msg;
cf03fd63
NB		 1783
1784 /* Get the translation. */
1785 help = _(help);
1786
1787 tab = strchr (help, '\t');
1788 if (tab)
1789 {
1790 len = tab - help;
1791 opt = help;
1792 help = tab + 1;
1793 }
1794 else
1795 {
1796 opt = cl_options[i].opt_text;
1797 len = strlen (opt);
1798 }
1799
1800 wrap_help (help, opt, len);
1801 }
2cc98056
NB		 1802
1803 putchar ('\n');
1804}
1805
1806/* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1807 word-wrapped HELP in a second column. */
1808static unsigned int
1809print_switch (const char *text, unsigned int indent)
1810{
1811 unsigned int len = strlen (text) + 1; /* trailing comma */
1812
1813 if (indent)
1814 {
1815 putchar (',');
1816 if (indent + len > columns)
1817 {
1818 putchar ('\n');
1819 putchar (' ');
1820 indent = 1;
1821 }
1822 }
1823 else
1824 putchar (' ');
1825
1826 putchar (' ');
1827 fputs (text, stdout);
1828
1829 return indent + len + 1;
cf03fd63
NB		 1830}
1831
1832/* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1833 word-wrapped HELP in a second column. */
1834static void
2cc98056 1835wrap_help (const char *help, const char *item, unsigned int item_width)
cf03fd63 1836{
2cc98056 1837 unsigned int col_width = 27;
21789816 1838 unsigned int remaining, room, len;
cf03fd63
NB		 1839
1840 remaining = strlen (help);
1841
1842 do
1843 {
1844 room = columns - 3 - MAX (col_width, item_width);
2cc98056
NB		 1845 if (room > columns)
1846 room = 0;
cf03fd63
NB		 1847 len = remaining;
1848
1849 if (room < len)
1850 {
21789816 1851 unsigned int i;
cf03fd63
NB		 1852
1853 for (i = 0; help[i]; i++)
1854 {
1855 if (i >= room && len != remaining)
1856 break;
1857 if (help[i] == ' ')
1858 len = i;
2cc98056
NB		 1859 else if ((help[i] == '-' || help[i] == '/')
1860 && help[i + 1] != ' '
b50d9339 1861 && i > 0 && ISALPHA (help[i - 1]))
cf03fd63
NB		 1862 len = i + 1;
1863 }
1864 }
1865
1866 printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
1867 item_width = 0;
1868 while (help[len] == ' ')
1869 len++;
1870 help += len;
1871 remaining -= len;
1872 }
1873 while (remaining);
1874}
GNU Compiler Collection
This page took 0.49769 seconds and 5 git commands to generate.