1 /* Command line option handling.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
4 Contributed by Neil Booth.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
21 02110-1301, USA. */
22
23 #include "config.h"
24 #include "system.h"
25 #include "intl.h"
26 #include "coretypes.h"
27 #include "tm.h"
28 #include "tree.h"
29 #include "rtl.h"
30 #include "ggc.h"
31 #include "output.h"
32 #include "langhooks.h"
33 #include "opts.h"
34 #include "options.h"
35 #include "flags.h"
36 #include "toplev.h"
37 #include "params.h"
38 #include "diagnostic.h"
39 #include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
40 #include "insn-attr.h" /* For INSN_SCHEDULING. */
41 #include "target.h"
42 #include "tree-pass.h"
43
44 /* Value of the -G xx switch, and whether it was passed or not. */
45 unsigned HOST_WIDE_INT g_switch_value;
46 bool g_switch_set;
47
48 /* True if we should exit after parsing options. */
49 bool exit_after_options;
50
51 /* Print various extra warnings. -W/-Wextra. */
52 bool extra_warnings;
53
54 /* True to warn about any objects definitions whose size is larger
55 than N bytes. Also want about function definitions whose returned
56 values are larger than N bytes, where N is `larger_than_size'. */
57 bool warn_larger_than;
58 HOST_WIDE_INT larger_than_size;
59
60 /* Nonzero means warn about any function whose stack usage is larger
61 than N bytes. The value N is in `stack_larger_than_size'. */
62 int warn_stack_larger_than;
63 HOST_WIDE_INT stack_larger_than_size;
64
65 /* Nonzero means warn about constructs which might not be
66 strict-aliasing safe. */
67 int warn_strict_aliasing;
68
69 /* Nonzero means warn about optimizations which rely on undefined
70 signed overflow. */
71 int warn_strict_overflow;
72
73 /* Hack for cooperation between set_Wunused and set_Wextra. */
74 static bool maybe_warn_unused_parameter;
75
76 /* Type(s) of debugging information we are producing (if any). See
77 flags.h for the definitions of the different possible types of
78 debugging information. */
79 enum debug_info_type write_symbols = NO_DEBUG;
80
81 /* Level of debugging information we are producing. See flags.h for
82 the definitions of the different possible levels. */
83 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
84
85 /* Nonzero means use GNU-only extensions in the generated symbolic
86 debugging information. Currently, this only has an effect when
87 write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
88 bool use_gnu_debug_info_extensions;
89
90 /* The default visibility for all symbols (unless overridden) */
91 enum symbol_visibility default_visibility = VISIBILITY_DEFAULT;
92
93 /* Disable unit-at-a-time for frontends that might be still broken in this
94 respect. */
95
96 bool no_unit_at_a_time_default;
97
98 /* Global visibility options. */
99 struct visibility_flags visibility_options;
100
101 /* Columns of --help display. */
102 static unsigned int columns = 80;
103
104 /* What to print when a switch has no documentation. */
105 static const char undocumented_msg[] = N_("This switch lacks documentation");
106
107 /* Used for bookkeeping on whether user set these flags so
108 -fprofile-use/-fprofile-generate does not use them. */
109 static bool profile_arc_flag_set, flag_profile_values_set;
110 static bool flag_unroll_loops_set, flag_tracer_set;
111 static bool flag_value_profile_transformations_set;
112 static bool flag_peel_loops_set, flag_branch_probabilities_set;
113
114 /* Input file names. */
115 const char **in_fnames;
116 unsigned num_in_fnames;
117
118 static int common_handle_option (size_t scode, const char *arg, int value,
119 unsigned int lang_mask);
120 static void handle_param (const char *);
121 static void set_Wextra (int);
122 static unsigned int handle_option (const char **argv, unsigned int lang_mask);
123 static char *write_langs (unsigned int lang_mask);
124 static void complain_wrong_lang (const char *, const struct cl_option *,
125 unsigned int lang_mask);
126 static void handle_options (unsigned int, const char **, unsigned int);
127 static void wrap_help (const char *help, const char *item, unsigned int);
128 static void print_target_help (void);
129 static void print_help (void);
130 static void print_param_help (void);
131 static void print_filtered_help (unsigned int);
132 static unsigned int print_switch (const char *text, unsigned int indent);
133 static void set_debug_level (enum debug_info_type type, int extended,
134 const char *arg);
135
136 /* If ARG is a non-negative integer made up solely of digits, return its
137 value, otherwise return -1. */
138 static int
integral_argument(const char * arg)139 integral_argument (const char *arg)
140 {
141 const char *p = arg;
142
143 while (*p && ISDIGIT (*p))
144 p++;
145
146 if (*p == '\0')
147 return atoi (arg);
148
149 return -1;
150 }
151
152 /* Return a malloced slash-separated list of languages in MASK. */
153 static char *
write_langs(unsigned int mask)154 write_langs (unsigned int mask)
155 {
156 unsigned int n = 0, len = 0;
157 const char *lang_name;
158 char *result;
159
160 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
161 if (mask & (1U << n))
162 len += strlen (lang_name) + 1;
163
164 result = XNEWVEC (char, len);
165 len = 0;
166 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
167 if (mask & (1U << n))
168 {
169 if (len)
170 result[len++] = '/';
171 strcpy (result + len, lang_name);
172 len += strlen (lang_name);
173 }
174
175 result[len] = 0;
176
177 return result;
178 }
179
180 /* Complain that switch OPT_INDEX does not apply to this front end. */
181 static void
complain_wrong_lang(const char * text,const struct cl_option * option,unsigned int lang_mask)182 complain_wrong_lang (const char *text, const struct cl_option *option,
183 unsigned int lang_mask)
184 {
185 char *ok_langs, *bad_lang;
186
187 ok_langs = write_langs (option->flags);
188 bad_lang = write_langs (lang_mask);
189
190 /* Eventually this should become a hard error IMO. */
191 warning (0, "command line option \"%s\" is valid for %s but not for %s",
192 text, ok_langs, bad_lang);
193
194 free (ok_langs);
195 free (bad_lang);
196 }
197
198 static const char *bad_option = NULL;
199
200 void
late_options_error(void)201 late_options_error (void)
202 {
203 if (bad_option)
204 {
205 input_location = unknown_location;
206 error ("unrecognized command line option \"%s\"", bad_option);
207 }
208 }
209
210 /* Handle the switch beginning at ARGV for the language indicated by
211 LANG_MASK. Returns the number of switches consumed. */
212 static unsigned int
handle_option(const char ** argv,unsigned int lang_mask)213 handle_option (const char **argv, unsigned int lang_mask)
214 {
215 size_t opt_index;
216 const char *opt, *arg = 0;
217 char *dup = 0;
218 int value = 1;
219 unsigned int result = 0;
220 const struct cl_option *option;
221
222 opt = argv[0];
223
224 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
225 if (opt_index == cl_options_count
226 && (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm')
227 && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
228 {
229 /* Drop the "no-" from negative switches. */
230 size_t len = strlen (opt) - 3;
231
232 dup = XNEWVEC (char, len + 1);
233 dup[0] = '-';
234 dup[1] = opt[1];
235 memcpy (dup + 2, opt + 5, len - 2 + 1);
236 opt = dup;
237 value = 0;
238 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
239 }
240
241 if (opt_index == cl_options_count)
242 {
243 /* ignore unknown -Wno-* options */
244 if (value == 0 && opt[1] == 'W')
245 {
246 bad_option = argv[0];
247 result = 1;
248 }
249 goto done;
250 }
251
252 option = &cl_options[opt_index];
253
254 /* Reject negative form of switches that don't take negatives as
255 unrecognized. */
256 if (!value && (option->flags & CL_REJECT_NEGATIVE))
257 goto done;
258
259 /* We've recognized this switch. */
260 result = 1;
261
262 /* Check to see if the option is disabled for this configuration. */
263 if (option->flags & CL_DISABLED)
264 {
265 error ("command line option %qs"
266 " is not supported by this configuration", opt);
267 goto done;
268 }
269
270 /* Sort out any argument the switch takes. */
271 if (option->flags & CL_JOINED)
272 {
273 /* Have arg point to the original switch. This is because
274 some code, such as disable_builtin_function, expects its
275 argument to be persistent until the program exits. */
276 arg = argv[0] + cl_options[opt_index].opt_len + 1;
277 if (!value)
278 arg += strlen ("no-");
279
280 if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
281 {
282 if (option->flags & CL_SEPARATE)
283 {
284 arg = argv[1];
285 result = 2;
286 }
287 else
288 /* Missing argument. */
289 arg = NULL;
290 }
291 }
292 else if (option->flags & CL_SEPARATE)
293 {
294 arg = argv[1];
295 result = 2;
296 }
297
298 /* Now we've swallowed any potential argument, complain if this
299 is a switch for a different front end. */
300 if (!(option->flags & (lang_mask | CL_COMMON | CL_TARGET)))
301 {
302 complain_wrong_lang (argv[0], option, lang_mask);
303 goto done;
304 }
305
306 if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
307 {
308 if (!lang_hooks.missing_argument (opt, opt_index))
309 error ("missing argument to \"%s\"", opt);
310 goto done;
311 }
312
313 /* If the switch takes an integer, convert it. */
314 if (arg && (option->flags & CL_UINTEGER))
315 {
316 value = integral_argument (arg);
317 if (value == -1)
318 {
319 error ("argument to \"%s\" should be a non-negative integer",
320 option->opt_text);
321 goto done;
322 }
323 }
324
325 if (option->flag_var)
326 switch (option->var_type)
327 {
328 case CLVC_BOOLEAN:
329 *(int *) option->flag_var = value;
330 break;
331
332 case CLVC_EQUAL:
333 *(int *) option->flag_var = (value
334 ? option->var_value
335 : !option->var_value);
336 break;
337
338 case CLVC_BIT_CLEAR:
339 case CLVC_BIT_SET:
340 if ((value != 0) == (option->var_type == CLVC_BIT_SET))
341 *(int *) option->flag_var |= option->var_value;
342 else
343 *(int *) option->flag_var &= ~option->var_value;
344 if (option->flag_var == &target_flags)
345 target_flags_explicit |= option->var_value;
346 break;
347
348 case CLVC_STRING:
349 *(const char **) option->flag_var = arg;
350 break;
351 }
352
353 if (option->flags & lang_mask)
354 if (lang_hooks.handle_option (opt_index, arg, value) == 0)
355 result = 0;
356
357 if (result && (option->flags & CL_COMMON))
358 if (common_handle_option (opt_index, arg, value, lang_mask) == 0)
359 result = 0;
360
361 if (result && (option->flags & CL_TARGET))
362 if (!targetm.handle_option (opt_index, arg, value))
363 result = 0;
364
365 done:
366 if (dup)
367 free (dup);
368 return result;
369 }
370
371 /* Handle FILENAME from the command line. */
372 static void
add_input_filename(const char * filename)373 add_input_filename (const char *filename)
374 {
375 num_in_fnames++;
376 in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0]));
377 in_fnames[num_in_fnames - 1] = filename;
378 }
379
380 /* Decode and handle the vector of command line options. LANG_MASK
381 contains has a single bit set representing the current
382 language. */
383 static void
handle_options(unsigned int argc,const char ** argv,unsigned int lang_mask)384 handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
385 {
386 unsigned int n, i;
387
388 for (i = 1; i < argc; i += n)
389 {
390 const char *opt = argv[i];
391
392 /* Interpret "-" or a non-switch as a file name. */
393 if (opt[0] != '-' || opt[1] == '\0')
394 {
395 if (main_input_filename == NULL)
396 main_input_filename = opt;
397 add_input_filename (opt);
398 n = 1;
399 continue;
400 }
401
402 n = handle_option (argv + i, lang_mask);
403
404 if (!n)
405 {
406 n = 1;
407 error ("unrecognized command line option \"%s\"", opt);
408 }
409 }
410 }
411
412 /* Parse command line options and set default flag values. Do minimal
413 options processing. */
414 void
decode_options(unsigned int argc,const char ** argv)415 decode_options (unsigned int argc, const char **argv)
416 {
417 unsigned int i, lang_mask;
418
419 /* Perform language-specific options initialization. */
420 lang_mask = lang_hooks.init_options (argc, argv);
421
422 lang_hooks.initialize_diagnostics (global_dc);
423
424 /* Scan to see what optimization level has been specified. That will
425 determine the default value of many flags. */
426 for (i = 1; i < argc; i++)
427 {
428 if (!strcmp (argv[i], "-O"))
429 {
430 optimize = 1;
431 optimize_size = 0;
432 }
433 else if (argv[i][0] == '-' && argv[i][1] == 'O')
434 {
435 /* Handle -Os, -O2, -O3, -O69, ... */
436 const char *p = &argv[i][2];
437
438 if ((p[0] == 's' || p[0] == 'z') && (p[1] == 0))
439 {
440 optimize_size = 1;
441
442 /* Optimizing for size forces optimize to be 2. */
443 optimize = 2;
444 }
445 else
446 {
447 const int optimize_val = read_integral_parameter (p, p - 2, -1);
448 if (optimize_val != -1)
449 {
450 optimize = optimize_val;
451 optimize_size = 0;
452 }
453 }
454 }
455 }
456
457 if (!optimize)
458 {
459 flag_merge_constants = 0;
460 }
461
462 if (optimize >= 1)
463 {
464 flag_defer_pop = 1;
465 #ifdef DELAY_SLOTS
466 flag_delayed_branch = 1;
467 #endif
468 #ifdef CAN_DEBUG_WITHOUT_FP
469 flag_omit_frame_pointer = 1;
470 #endif
471 flag_guess_branch_prob = 1;
472 flag_cprop_registers = 1;
473 flag_if_conversion = 1;
474 flag_if_conversion2 = 1;
475 flag_ipa_pure_const = 1;
476 flag_ipa_reference = 1;
477 flag_tree_ccp = 1;
478 flag_tree_dce = 1;
479 flag_tree_dom = 1;
480 flag_tree_dse = 1;
481 flag_tree_ter = 1;
482 flag_tree_live_range_split = 1;
483 flag_tree_sra = 1;
484 flag_tree_copyrename = 1;
485 flag_tree_fre = 1;
486 flag_tree_copy_prop = 1;
487 flag_tree_sink = 1;
488 flag_tree_salias = 1;
489 if (!no_unit_at_a_time_default)
490 flag_unit_at_a_time = 1;
491
492 if (!optimize_size)
493 {
494 /* Loop header copying usually increases size of the code. This used
495 not to be true, since quite often it is possible to verify that
496 the condition is satisfied in the first iteration and therefore
497 to eliminate it. Jump threading handles these cases now. */
498 flag_tree_ch = 1;
499 }
500 }
501
502 if (optimize >= 2)
503 {
504 flag_thread_jumps = 1;
505 flag_crossjumping = 1;
506 flag_optimize_sibling_calls = 1;
507 flag_cse_follow_jumps = 1;
508 flag_cse_skip_blocks = 1;
509 flag_gcse = 1;
510 flag_expensive_optimizations = 1;
511 flag_ipa_type_escape = 1;
512 flag_rerun_cse_after_loop = 1;
513 flag_caller_saves = 1;
514 flag_peephole2 = 1;
515 #ifdef INSN_SCHEDULING
516 flag_schedule_insns = 1;
517 flag_schedule_insns_after_reload = 1;
518 #endif
519 flag_regmove = 1;
520 #if !defined(OPENBSD_NATIVE) && !defined(OPENBSD_CROSS)
521 flag_strict_overflow = 1;
522 flag_delete_null_pointer_checks = 1;
523 #endif
524 flag_reorder_blocks = 1;
525 flag_reorder_functions = 1;
526 flag_tree_store_ccp = 1;
527 flag_tree_store_copy_prop = 1;
528
529 if (!optimize_size)
530 {
531 /* PRE tends to generate bigger code. */
532 flag_tree_pre = 1;
533 }
534 }
535
536 if (optimize >= 3)
537 {
538 flag_strict_aliasing = 1;
539 flag_inline_functions = 1;
540 flag_unswitch_loops = 1;
541 flag_gcse_after_reload = 1;
542 }
543
544 if (optimize < 2 || optimize_size)
545 {
546 align_loops = 1;
547 align_jumps = 1;
548 align_labels = 1;
549 align_functions = 1;
550
551 /* Don't reorder blocks when optimizing for size because extra
552 jump insns may be created; also barrier may create extra padding.
553
554 More correctly we should have a block reordering mode that tried
555 to minimize the combined size of all the jumps. This would more
556 or less automatically remove extra jumps, but would also try to
557 use more short jumps instead of long jumps. */
558 flag_reorder_blocks = 0;
559 flag_reorder_blocks_and_partition = 0;
560 }
561
562 if (optimize_size)
563 {
564 /* Inlining of very small functions usually reduces total size. */
565 set_param_value ("max-inline-insns-single", 5);
566 set_param_value ("max-inline-insns-auto", 5);
567 flag_inline_functions = 1;
568
569 /* We want to crossjump as much as possible. */
570 set_param_value ("min-crossjump-insns", 1);
571 }
572
573 /* Initialize whether `char' is signed. */
574 flag_signed_char = DEFAULT_SIGNED_CHAR;
575 /* Set this to a special "uninitialized" value. The actual default is set
576 after target options have been processed. */
577 flag_short_enums = 2;
578
579 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
580 modify it. */
581 target_flags = targetm.default_target_flags;
582
583 /* Some tagets have ABI-specified unwind tables. */
584 flag_unwind_tables = targetm.unwind_tables_default;
585
586 #ifdef OPTIMIZATION_OPTIONS
587 /* Allow default optimizations to be specified on a per-machine basis. */
588 OPTIMIZATION_OPTIONS (optimize, optimize_size);
589 #endif
590
591 handle_options (argc, argv, lang_mask);
592
593 if (flag_pic || profile_flag)
594 flag_pie = 0;
595 if (flag_pie)
596 flag_pic = flag_pie;
597 if (flag_pic && !flag_pie)
598 flag_shlib = 1;
599
600 if (flag_no_inline == 2)
601 flag_no_inline = 0;
602 else
603 flag_really_no_inline = flag_no_inline;
604
605 /* Set flag_no_inline before the post_options () hook. The C front
606 ends use it to determine tree inlining defaults. FIXME: such
607 code should be lang-independent when all front ends use tree
608 inlining, in which case it, and this condition, should be moved
609 to the top of process_options() instead. */
610 if (optimize == 0)
611 {
612 /* Inlining does not work if not optimizing,
613 so force it not to be done. */
614 flag_no_inline = 1;
615 warn_inline = 0;
616
617 /* The c_decode_option function and decode_option hook set
618 this to `2' if -Wall is used, so we can avoid giving out
619 lots of errors for people who don't realize what -Wall does. */
620 if (warn_uninitialized == 1)
621 warning (OPT_Wuninitialized,
622 "-Wuninitialized is not supported without -O");
623 }
624
625 if (flag_really_no_inline == 2)
626 flag_really_no_inline = flag_no_inline;
627
628 /* The optimization to partition hot and cold basic blocks into separate
629 sections of the .o and executable files does not work (currently)
630 with exception handling. This is because there is no support for
631 generating unwind info. If flag_exceptions is turned on we need to
632 turn off the partitioning optimization. */
633
634 if (flag_exceptions && flag_reorder_blocks_and_partition)
635 {
636 inform
637 ("-freorder-blocks-and-partition does not work with exceptions");
638 flag_reorder_blocks_and_partition = 0;
639 flag_reorder_blocks = 1;
640 }
641
642 /* If user requested unwind info, then turn off the partitioning
643 optimization. */
644
645 if (flag_unwind_tables && ! targetm.unwind_tables_default
646 && flag_reorder_blocks_and_partition)
647 {
648 inform ("-freorder-blocks-and-partition does not support unwind info");
649 flag_reorder_blocks_and_partition = 0;
650 flag_reorder_blocks = 1;
651 }
652
653 /* If the target requested unwind info, then turn off the partitioning
654 optimization with a different message. Likewise, if the target does not
655 support named sections. */
656
657 if (flag_reorder_blocks_and_partition
658 && (!targetm.have_named_sections
659 || (flag_unwind_tables && targetm.unwind_tables_default)))
660 {
661 inform
662 ("-freorder-blocks-and-partition does not work on this architecture");
663 flag_reorder_blocks_and_partition = 0;
664 flag_reorder_blocks = 1;
665 }
666 }
667
668 /* Handle target- and language-independent options. Return zero to
669 generate an "unknown option" message. Only options that need
670 extra handling need to be listed here; if you simply want
671 VALUE assigned to a variable, it happens automatically. */
672
673 static int
common_handle_option(size_t scode,const char * arg,int value,unsigned int lang_mask)674 common_handle_option (size_t scode, const char *arg, int value,
675 unsigned int lang_mask)
676 {
677 enum opt_code code = (enum opt_code) scode;
678
679 switch (code)
680 {
681 case OPT__help:
682 print_help ();
683 exit_after_options = true;
684 break;
685
686 case OPT__param:
687 handle_param (arg);
688 break;
689
690 case OPT__target_help:
691 print_target_help ();
692 exit_after_options = true;
693 break;
694
695 case OPT__version:
696 print_version (stderr, "");
697 exit_after_options = true;
698 break;
699
700 case OPT_G:
701 g_switch_value = value;
702 g_switch_set = true;
703 break;
704
705 case OPT_O:
706 case OPT_Os:
707 /* Currently handled in a prescan. */
708 break;
709
710 case OPT_W:
711 /* For backward compatibility, -W is the same as -Wextra. */
712 set_Wextra (value);
713 break;
714
715 case OPT_Werror_:
716 {
717 char *new_option;
718 int option_index;
719 new_option = XNEWVEC (char, strlen (arg) + 2);
720 new_option[0] = 'W';
721 strcpy (new_option+1, arg);
722 option_index = find_opt (new_option, lang_mask);
723 if (option_index == N_OPTS)
724 {
725 error ("-Werror=%s: No option -%s", arg, new_option);
726 }
727 else
728 {
729 int kind = value ? DK_ERROR : DK_WARNING;
730 diagnostic_classify_diagnostic (global_dc, option_index, kind);
731
732 /* -Werror=foo implies -Wfoo. */
733 if (cl_options[option_index].var_type == CLVC_BOOLEAN
734 && cl_options[option_index].flag_var
735 && kind == DK_ERROR)
736 *(int *) cl_options[option_index].flag_var = 1;
737 free (new_option);
738 }
739 }
740 break;
741
742 case OPT_Wextra:
743 set_Wextra (value);
744 break;
745
746 case OPT_Wlarger_than_:
747 larger_than_size = value;
748 warn_larger_than = value != -1;
749 break;
750
751 case OPT_Wframe_larger_than_:
752 case OPT_Wstack_larger_than_:
753 stack_larger_than_size = value;
754 warn_stack_larger_than = stack_larger_than_size != -1;
755 break;
756
757 case OPT_Wstrict_aliasing:
758 case OPT_Wstrict_aliasing_:
759 warn_strict_aliasing = value;
760 break;
761
762 case OPT_Wstrict_overflow:
763 warn_strict_overflow = (value
764 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
765 : 0);
766 break;
767
768 case OPT_Wstrict_overflow_:
769 warn_strict_overflow = value;
770 break;
771
772 case OPT_Wunused:
773 set_Wunused (value);
774 break;
775
776 case OPT_aux_info:
777 case OPT_aux_info_:
778 aux_info_file_name = arg;
779 flag_gen_aux_info = 1;
780 break;
781
782 case OPT_auxbase:
783 aux_base_name = arg;
784 break;
785
786 case OPT_auxbase_strip:
787 {
788 char *tmp = xstrdup (arg);
789 strip_off_ending (tmp, strlen (tmp));
790 if (tmp[0])
791 aux_base_name = tmp;
792 }
793 break;
794
795 case OPT_d:
796 decode_d_option (arg);
797 break;
798
799 case OPT_dumpbase:
800 dump_base_name = arg;
801 break;
802
803 case OPT_falign_functions_:
804 align_functions = value;
805 break;
806
807 case OPT_falign_jumps_:
808 align_jumps = value;
809 break;
810
811 case OPT_falign_labels_:
812 align_labels = value;
813 break;
814
815 case OPT_falign_loops_:
816 align_loops = value;
817 break;
818
819 case OPT_fbranch_probabilities:
820 flag_branch_probabilities_set = true;
821 break;
822
823 case OPT_fcall_used_:
824 fix_register (arg, 0, 1);
825 break;
826
827 case OPT_fcall_saved_:
828 fix_register (arg, 0, 0);
829 break;
830
831 case OPT_fdiagnostics_show_location_:
832 if (!strcmp (arg, "once"))
833 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
834 else if (!strcmp (arg, "every-line"))
835 diagnostic_prefixing_rule (global_dc)
836 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
837 else
838 return 0;
839 break;
840
841 case OPT_fdiagnostics_show_option:
842 global_dc->show_option_requested = true;
843 break;
844
845 case OPT_fdump_:
846 if (!dump_switch_p (arg))
847 return 0;
848 break;
849
850 case OPT_ffast_math:
851 set_fast_math_flags (value);
852 break;
853
854 case OPT_ffixed_:
855 fix_register (arg, 1, 1);
856 break;
857
858 case OPT_finline_limit_:
859 case OPT_finline_limit_eq:
860 set_param_value ("max-inline-insns-single", value / 2);
861 set_param_value ("max-inline-insns-auto", value / 2);
862 break;
863
864 case OPT_fmessage_length_:
865 pp_set_line_maximum_length (global_dc->printer, value);
866 break;
867
868 case OPT_fpack_struct_:
869 if (value <= 0 || (value & (value - 1)) || value > 16)
870 error("structure alignment must be a small power of two, not %d", value);
871 else
872 {
873 initial_max_fld_align = value;
874 maximum_field_alignment = value * BITS_PER_UNIT;
875 }
876 break;
877
878 case OPT_fpeel_loops:
879 flag_peel_loops_set = true;
880 break;
881
882 case OPT_fprofile_arcs:
883 profile_arc_flag_set = true;
884 break;
885
886 case OPT_fprofile_use:
887 if (!flag_branch_probabilities_set)
888 flag_branch_probabilities = value;
889 if (!flag_profile_values_set)
890 flag_profile_values = value;
891 if (!flag_unroll_loops_set)
892 flag_unroll_loops = value;
893 if (!flag_peel_loops_set)
894 flag_peel_loops = value;
895 if (!flag_tracer_set)
896 flag_tracer = value;
897 if (!flag_value_profile_transformations_set)
898 flag_value_profile_transformations = value;
899 break;
900
901 case OPT_fprofile_generate:
902 if (!profile_arc_flag_set)
903 profile_arc_flag = value;
904 if (!flag_profile_values_set)
905 flag_profile_values = value;
906 if (!flag_value_profile_transformations_set)
907 flag_value_profile_transformations = value;
908 break;
909
910 case OPT_fprofile_values:
911 flag_profile_values_set = true;
912 break;
913
914 case OPT_fvisibility_:
915 {
916 if (!strcmp(arg, "default"))
917 default_visibility = VISIBILITY_DEFAULT;
918 else if (!strcmp(arg, "internal"))
919 default_visibility = VISIBILITY_INTERNAL;
920 else if (!strcmp(arg, "hidden"))
921 default_visibility = VISIBILITY_HIDDEN;
922 else if (!strcmp(arg, "protected"))
923 default_visibility = VISIBILITY_PROTECTED;
924 else
925 error ("unrecognized visibility value \"%s\"", arg);
926 }
927 break;
928
929 case OPT_fvpt:
930 flag_value_profile_transformations_set = true;
931 break;
932
933 case OPT_frandom_seed:
934 /* The real switch is -fno-random-seed. */
935 if (value)
936 return 0;
937 flag_random_seed = NULL;
938 break;
939
940 case OPT_frandom_seed_:
941 flag_random_seed = arg;
942 break;
943
944 case OPT_fsched_verbose_:
945 #ifdef INSN_SCHEDULING
946 fix_sched_param ("verbose", arg);
947 break;
948 #else
949 return 0;
950 #endif
951
952 case OPT_fsched_stalled_insns_:
953 flag_sched_stalled_insns = value;
954 if (flag_sched_stalled_insns == 0)
955 flag_sched_stalled_insns = -1;
956 break;
957
958 case OPT_fsched_stalled_insns_dep_:
959 flag_sched_stalled_insns_dep = value;
960 break;
961
962 case OPT_fstack_limit:
963 /* The real switch is -fno-stack-limit. */
964 if (value)
965 return 0;
966 stack_limit_rtx = NULL_RTX;
967 break;
968
969 case OPT_fstack_limit_register_:
970 {
971 int reg = decode_reg_name (arg);
972 if (reg < 0)
973 error ("unrecognized register name \"%s\"", arg);
974 else
975 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
976 }
977 break;
978
979 case OPT_fstack_limit_symbol_:
980 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
981 break;
982
983 case OPT_ftree_vectorizer_verbose_:
984 vect_set_verbosity_level (arg);
985 break;
986
987 case OPT_ftls_model_:
988 if (!strcmp (arg, "global-dynamic"))
989 flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
990 else if (!strcmp (arg, "local-dynamic"))
991 flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
992 else if (!strcmp (arg, "initial-exec"))
993 flag_tls_default = TLS_MODEL_INITIAL_EXEC;
994 else if (!strcmp (arg, "local-exec"))
995 flag_tls_default = TLS_MODEL_LOCAL_EXEC;
996 else
997 warning (0, "unknown tls-model \"%s\"", arg);
998 break;
999
1000 case OPT_ftracer:
1001 flag_tracer_set = true;
1002 break;
1003
1004 case OPT_funroll_loops:
1005 flag_unroll_loops_set = true;
1006 break;
1007
1008 case OPT_g:
1009 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
1010 break;
1011
1012 case OPT_gcoff:
1013 set_debug_level (SDB_DEBUG, false, arg);
1014 break;
1015
1016 case OPT_gdwarf_2:
1017 set_debug_level (DWARF2_DEBUG, false, arg);
1018 break;
1019
1020 case OPT_ggdb:
1021 set_debug_level (NO_DEBUG, 2, arg);
1022 break;
1023
1024 case OPT_gstabs:
1025 case OPT_gstabs_:
1026 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
1027 break;
1028
1029 case OPT_gvms:
1030 set_debug_level (VMS_DEBUG, false, arg);
1031 break;
1032
1033 case OPT_gxcoff:
1034 case OPT_gxcoff_:
1035 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
1036 break;
1037
1038 case OPT_o:
1039 asm_file_name = arg;
1040 break;
1041
1042 case OPT_pedantic_errors:
1043 flag_pedantic_errors = pedantic = 1;
1044 break;
1045
1046 case OPT_fforce_mem:
1047 warning (0, "-f[no-]force-mem is nop and option will be removed in 4.3");
1048 break;
1049
1050 case OPT_floop_optimize:
1051 case OPT_frerun_loop_opt:
1052 case OPT_fstrength_reduce:
1053 /* These are no-ops, preserved for backward compatibility. */
1054 break;
1055
1056 default:
1057 /* If the flag was handled in a standard way, assume the lack of
1058 processing here is intentional. */
1059 gcc_assert (cl_options[scode].flag_var);
1060 break;
1061 }
1062
1063 return 1;
1064 }
1065
1066 /* Handle --param NAME=VALUE. */
1067 static void
handle_param(const char * carg)1068 handle_param (const char *carg)
1069 {
1070 char *equal, *arg;
1071 int value;
1072
1073 arg = xstrdup (carg);
1074 equal = strchr (arg, '=');
1075 if (!equal)
1076 error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1077 else
1078 {
1079 value = integral_argument (equal + 1);
1080 if (value == -1)
1081 error ("invalid --param value %qs", equal + 1);
1082 else
1083 {
1084 *equal = '\0';
1085 set_param_value (arg, value);
1086 }
1087 }
1088
1089 free (arg);
1090 }
1091
1092 /* Handle -W and -Wextra. */
1093 static void
set_Wextra(int setting)1094 set_Wextra (int setting)
1095 {
1096 extra_warnings = setting;
1097 warn_unused_value = setting;
1098 warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1099
1100 /* We save the value of warn_uninitialized, since if they put
1101 -Wuninitialized on the command line, we need to generate a
1102 warning about not using it without also specifying -O. */
1103 if (setting == 0)
1104 warn_uninitialized = 0;
1105 else if (warn_uninitialized != 1)
1106 warn_uninitialized = 2;
1107 }
1108
1109 /* Initialize unused warning flags. */
1110 void
set_Wunused(int setting)1111 set_Wunused (int setting)
1112 {
1113 warn_unused_function = setting;
1114 warn_unused_label = setting;
1115 /* Unused function parameter warnings are reported when either
1116 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1117 Thus, if -Wextra has already been seen, set warn_unused_parameter;
1118 otherwise set maybe_warn_extra_parameter, which will be picked up
1119 by set_Wextra. */
1120 maybe_warn_unused_parameter = setting;
1121 warn_unused_parameter = (setting && extra_warnings);
1122 warn_unused_variable = setting;
1123 warn_unused_value = setting;
1124 }
1125
1126 /* The following routines are useful in setting all the flags that
1127 -ffast-math and -fno-fast-math imply. */
1128 void
set_fast_math_flags(int set)1129 set_fast_math_flags (int set)
1130 {
1131 flag_trapping_math = !set;
1132 flag_unsafe_math_optimizations = set;
1133 flag_finite_math_only = set;
1134 flag_errno_math = !set;
1135 if (set)
1136 {
1137 flag_signaling_nans = 0;
1138 flag_rounding_math = 0;
1139 flag_cx_limited_range = 1;
1140 }
1141 }
1142
1143 /* Return true iff flags are set as if -ffast-math. */
1144 bool
fast_math_flags_set_p(void)1145 fast_math_flags_set_p (void)
1146 {
1147 return (!flag_trapping_math
1148 && flag_unsafe_math_optimizations
1149 && flag_finite_math_only
1150 && !flag_errno_math);
1151 }
1152
1153 /* Handle a debug output -g switch. EXTENDED is true or false to support
1154 extended output (2 is special and means "-ggdb" was given). */
1155 static void
set_debug_level(enum debug_info_type type,int extended,const char * arg)1156 set_debug_level (enum debug_info_type type, int extended, const char *arg)
1157 {
1158 static bool type_explicit;
1159
1160 use_gnu_debug_info_extensions = extended;
1161
1162 if (type == NO_DEBUG)
1163 {
1164 if (write_symbols == NO_DEBUG)
1165 {
1166 write_symbols = PREFERRED_DEBUGGING_TYPE;
1167
1168 if (extended == 2)
1169 {
1170 #ifdef DWARF2_DEBUGGING_INFO
1171 write_symbols = DWARF2_DEBUG;
1172 #elif defined DBX_DEBUGGING_INFO
1173 write_symbols = DBX_DEBUG;
1174 #endif
1175 }
1176
1177 if (write_symbols == NO_DEBUG)
1178 warning (0, "target system does not support debug output");
1179 }
1180 }
1181 else
1182 {
1183 /* Does it conflict with an already selected type? */
1184 if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1185 error ("debug format \"%s\" conflicts with prior selection",
1186 debug_type_names[type]);
1187 write_symbols = type;
1188 type_explicit = true;
1189 }
1190
1191 /* A debug flag without a level defaults to level 2. */
1192 if (*arg == '\0')
1193 {
1194 if (!debug_info_level)
1195 debug_info_level = 2;
1196 }
1197 else
1198 {
1199 debug_info_level = integral_argument (arg);
1200 if (debug_info_level == (unsigned int) -1)
1201 error ("unrecognised debug output level \"%s\"", arg);
1202 else if (debug_info_level > 3)
1203 error ("debug output level %s is too high", arg);
1204 }
1205 }
1206
1207 /* Display help for target options. */
1208 static void
print_target_help(void)1209 print_target_help (void)
1210 {
1211 unsigned int i;
1212 static bool displayed = false;
1213
1214 /* Avoid double printing for --help --target-help. */
1215 if (displayed)
1216 return;
1217
1218 displayed = true;
1219 for (i = 0; i < cl_options_count; i++)
1220 if ((cl_options[i].flags & (CL_TARGET | CL_UNDOCUMENTED)) == CL_TARGET)
1221 {
1222 printf (_("\nTarget specific options:\n"));
1223 print_filtered_help (CL_TARGET);
1224 break;
1225 }
1226 }
1227
1228 /* Output --help text. */
1229 static void
print_help(void)1230 print_help (void)
1231 {
1232 size_t i;
1233 const char *p;
1234
1235 GET_ENVIRONMENT (p, "COLUMNS");
1236 if (p)
1237 {
1238 int value = atoi (p);
1239 if (value > 0)
1240 columns = value;
1241 }
1242
1243 puts (_("The following options are language-independent:\n"));
1244
1245 print_filtered_help (CL_COMMON);
1246 print_param_help ();
1247
1248 for (i = 0; lang_names[i]; i++)
1249 {
1250 printf (_("The %s front end recognizes the following options:\n\n"),
1251 lang_names[i]);
1252 print_filtered_help (1U << i);
1253 }
1254 print_target_help ();
1255 }
1256
1257 /* Print the help for --param. */
1258 static void
print_param_help(void)1259 print_param_help (void)
1260 {
1261 size_t i;
1262
1263 puts (_("The --param option recognizes the following as parameters:\n"));
1264
1265 for (i = 0; i < LAST_PARAM; i++)
1266 {
1267 const char *help = compiler_params[i].help;
1268 const char *param = compiler_params[i].option;
1269
1270 if (help == NULL || *help == '\0')
1271 help = undocumented_msg;
1272
1273 /* Get the translation. */
1274 help = _(help);
1275
1276 wrap_help (help, param, strlen (param));
1277 }
1278
1279 putchar ('\n');
1280 }
1281
1282 /* Print help for a specific front-end, etc. */
1283 static void
print_filtered_help(unsigned int flag)1284 print_filtered_help (unsigned int flag)
1285 {
1286 unsigned int i, len, filter, indent = 0;
1287 bool duplicates = false;
1288 const char *help, *opt, *tab;
1289 static char *printed;
1290
1291 if (flag == CL_COMMON || flag == CL_TARGET)
1292 {
1293 filter = flag;
1294 if (!printed)
1295 printed = xmalloc (cl_options_count);
1296 memset (printed, 0, cl_options_count);
1297 }
1298 else
1299 {
1300 /* Don't print COMMON options twice. */
1301 filter = flag | CL_COMMON;
1302
1303 for (i = 0; i < cl_options_count; i++)
1304 {
1305 if ((cl_options[i].flags & filter) != flag)
1306 continue;
1307
1308 /* Skip help for internal switches. */
1309 if (cl_options[i].flags & CL_UNDOCUMENTED)
1310 continue;
1311
1312 /* Skip switches that have already been printed, mark them to be
1313 listed later. */
1314 if (printed[i])
1315 {
1316 duplicates = true;
1317 indent = print_switch (cl_options[i].opt_text, indent);
1318 }
1319 }
1320
1321 if (duplicates)
1322 {
1323 putchar ('\n');
1324 putchar ('\n');
1325 }
1326 }
1327
1328 for (i = 0; i < cl_options_count; i++)
1329 {
1330 if ((cl_options[i].flags & filter) != flag)
1331 continue;
1332
1333 /* Skip help for internal switches. */
1334 if (cl_options[i].flags & CL_UNDOCUMENTED)
1335 continue;
1336
1337 /* Skip switches that have already been printed. */
1338 if (printed[i])
1339 continue;
1340
1341 printed[i] = true;
1342
1343 help = cl_options[i].help;
1344 if (!help)
1345 help = undocumented_msg;
1346
1347 /* Get the translation. */
1348 help = _(help);
1349
1350 tab = strchr (help, '\t');
1351 if (tab)
1352 {
1353 len = tab - help;
1354 opt = help;
1355 help = tab + 1;
1356 }
1357 else
1358 {
1359 opt = cl_options[i].opt_text;
1360 len = strlen (opt);
1361 }
1362
1363 wrap_help (help, opt, len);
1364 }
1365
1366 putchar ('\n');
1367 }
1368
1369 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1370 word-wrapped HELP in a second column. */
1371 static unsigned int
print_switch(const char * text,unsigned int indent)1372 print_switch (const char *text, unsigned int indent)
1373 {
1374 unsigned int len = strlen (text) + 1; /* trailing comma */
1375
1376 if (indent)
1377 {
1378 putchar (',');
1379 if (indent + len > columns)
1380 {
1381 putchar ('\n');
1382 putchar (' ');
1383 indent = 1;
1384 }
1385 }
1386 else
1387 putchar (' ');
1388
1389 putchar (' ');
1390 fputs (text, stdout);
1391
1392 return indent + len + 1;
1393 }
1394
1395 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1396 word-wrapped HELP in a second column. */
1397 static void
wrap_help(const char * help,const char * item,unsigned int item_width)1398 wrap_help (const char *help, const char *item, unsigned int item_width)
1399 {
1400 unsigned int col_width = 27;
1401 unsigned int remaining, room, len;
1402
1403 remaining = strlen (help);
1404
1405 do
1406 {
1407 room = columns - 3 - MAX (col_width, item_width);
1408 if (room > columns)
1409 room = 0;
1410 len = remaining;
1411
1412 if (room < len)
1413 {
1414 unsigned int i;
1415
1416 for (i = 0; help[i]; i++)
1417 {
1418 if (i >= room && len != remaining)
1419 break;
1420 if (help[i] == ' ')
1421 len = i;
1422 else if ((help[i] == '-' || help[i] == '/')
1423 && help[i + 1] != ' '
1424 && i > 0 && ISALPHA (help[i - 1]))
1425 len = i + 1;
1426 }
1427 }
1428
1429 printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
1430 item_width = 0;
1431 while (help[len] == ' ')
1432 len++;
1433 help += len;
1434 remaining -= len;
1435 }
1436 while (remaining);
1437 }
1438
1439 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
1440 a simple on-off switch. */
1441
1442 int
option_enabled(int opt_idx)1443 option_enabled (int opt_idx)
1444 {
1445 const struct cl_option *option = &(cl_options[opt_idx]);
1446 if (option->flag_var)
1447 switch (option->var_type)
1448 {
1449 case CLVC_BOOLEAN:
1450 return *(int *) option->flag_var != 0;
1451
1452 case CLVC_EQUAL:
1453 return *(int *) option->flag_var == option->var_value;
1454
1455 case CLVC_BIT_CLEAR:
1456 return (*(int *) option->flag_var & option->var_value) == 0;
1457
1458 case CLVC_BIT_SET:
1459 return (*(int *) option->flag_var & option->var_value) != 0;
1460
1461 case CLVC_STRING:
1462 break;
1463 }
1464 return -1;
1465 }
1466
1467 /* Fill STATE with the current state of option OPTION. Return true if
1468 there is some state to store. */
1469
1470 bool
get_option_state(int option,struct cl_option_state * state)1471 get_option_state (int option, struct cl_option_state *state)
1472 {
1473 if (cl_options[option].flag_var == 0)
1474 return false;
1475
1476 switch (cl_options[option].var_type)
1477 {
1478 case CLVC_BOOLEAN:
1479 case CLVC_EQUAL:
1480 state->data = cl_options[option].flag_var;
1481 state->size = sizeof (int);
1482 break;
1483
1484 case CLVC_BIT_CLEAR:
1485 case CLVC_BIT_SET:
1486 state->ch = option_enabled (option);
1487 state->data = &state->ch;
1488 state->size = 1;
1489 break;
1490
1491 case CLVC_STRING:
1492 state->data = *(const char **) cl_options[option].flag_var;
1493 if (state->data == 0)
1494 state->data = "";
1495 state->size = strlen (state->data) + 1;
1496 break;
1497 }
1498 return true;
1499 }
1500