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