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