1/* Command line option handling. 2 Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc. 3 Contributed by Neil Booth. 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 2, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING. If not, write to the Free 19Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2002110-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. */ 44unsigned HOST_WIDE_INT g_switch_value; 45bool g_switch_set; 46 47/* True if we should exit after parsing options. */ 48bool exit_after_options; 49 50/* Print various extra warnings. -W/-Wextra. */ 51bool 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'. */ 56bool warn_larger_than; 57HOST_WIDE_INT larger_than_size; 58 59/* Nonzero means warn about constructs which might not be 60 strict-aliasing safe. */ 61int warn_strict_aliasing; 62 63/* Hack for cooperation between set_Wunused and set_Wextra. */ 64static 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. */ 69enum 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. */ 73enum 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. */ 78bool use_gnu_debug_info_extensions; 79 80/* The default visibility for all symbols (unless overridden) */ 81enum symbol_visibility default_visibility = VISIBILITY_DEFAULT; 82 83/* Global visibility options. */ 84struct visibility_flags visibility_options; 85 86/* Columns of --help display. */ 87static unsigned int columns = 80; 88 89/* What to print when a switch has no documentation. */ 90static 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. */ 94static bool profile_arc_flag_set, flag_profile_values_set; 95static bool flag_unroll_loops_set, flag_tracer_set; 96static bool flag_value_profile_transformations_set; 97static bool flag_peel_loops_set, flag_branch_probabilities_set; 98static bool flag_loop_optimize_set; 99 100/* Input file names. */ 101const char **in_fnames; 102unsigned num_in_fnames; 103 104static size_t find_opt (const char *, int); 105static int common_handle_option (size_t scode, const char *arg, int value); 106static void handle_param (const char *); 107static void set_Wextra (int); 108static unsigned int handle_option (const char **argv, unsigned int lang_mask); 109static char *write_langs (unsigned int lang_mask); 110static void complain_wrong_lang (const char *, const struct cl_option *, 111 unsigned int lang_mask); 112static void handle_options (unsigned int, const char **, unsigned int); 113static void wrap_help (const char *help, const char *item, unsigned int); 114static void print_target_help (void); 115static void print_help (void); 116static void print_param_help (void); 117static void print_filtered_help (unsigned int); 118static unsigned int print_switch (const char *text, unsigned int indent); 119static 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. */ 146static size_t 147find_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. */ 208static int 209integral_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. */ 223static char * 224write_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. */ 251static void 252complain_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. */ 270static unsigned int 271handle_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. */ 422static void 423add_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. */ 433static void 434handle_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. */ 464void 465decode_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 flag_delete_null_pointer_checks = 1; 574 flag_reorder_blocks = 1; 575 flag_reorder_functions = 1; 576 flag_tree_store_ccp = 1; 577 flag_tree_store_copy_prop = 1; 578 flag_tree_vrp = 1; 579 580 if (!optimize_size) 581 { 582 /* PRE tends to generate bigger code. */ 583 flag_tree_pre = 1; 584 } 585 } 586 587 if (optimize >= 3) 588 { 589 flag_inline_functions = 1; 590 flag_unswitch_loops = 1; 591 flag_gcse_after_reload = 1; 592 } 593 594 if (optimize < 2 || optimize_size) 595 { 596 align_loops = 1; 597 align_jumps = 1; 598 align_labels = 1; 599 align_functions = 1; 600 601 /* Don't reorder blocks when optimizing for size because extra 602 jump insns may be created; also barrier may create extra padding. 603 604 More correctly we should have a block reordering mode that tried 605 to minimize the combined size of all the jumps. This would more 606 or less automatically remove extra jumps, but would also try to 607 use more short jumps instead of long jumps. */ 608 flag_reorder_blocks = 0; 609 flag_reorder_blocks_and_partition = 0; 610 } 611 612 if (optimize_size) 613 { 614 /* Inlining of very small functions usually reduces total size. */ 615 set_param_value ("max-inline-insns-single", 5); 616 set_param_value ("max-inline-insns-auto", 5); 617 flag_inline_functions = 1; 618 619 /* We want to crossjump as much as possible. */ 620 set_param_value ("min-crossjump-insns", 1); 621 } 622 623 /* Initialize whether `char' is signed. */ 624 flag_signed_char = DEFAULT_SIGNED_CHAR; 625 /* Set this to a special "uninitialized" value. The actual default is set 626 after target options have been processed. */ 627 flag_short_enums = 2; 628 629 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can 630 modify it. */ 631 target_flags = targetm.default_target_flags; 632 633 /* Some tagets have ABI-specified unwind tables. */ 634 flag_unwind_tables = targetm.unwind_tables_default; 635 636#ifdef OPTIMIZATION_OPTIONS 637 /* Allow default optimizations to be specified on a per-machine basis. */ 638 OPTIMIZATION_OPTIONS (optimize, optimize_size); 639#endif 640 641 handle_options (argc, argv, lang_mask); 642 643 if (flag_pie) 644 flag_pic = flag_pie; 645 if (flag_pic && !flag_pie) 646 flag_shlib = 1; 647 648 if (flag_no_inline == 2) 649 flag_no_inline = 0; 650 else 651 flag_really_no_inline = flag_no_inline; 652 653 /* Set flag_no_inline before the post_options () hook. The C front 654 ends use it to determine tree inlining defaults. FIXME: such 655 code should be lang-independent when all front ends use tree 656 inlining, in which case it, and this condition, should be moved 657 to the top of process_options() instead. */ 658 if (optimize == 0) 659 { 660 /* Inlining does not work if not optimizing, 661 so force it not to be done. */ 662 flag_no_inline = 1; 663 warn_inline = 0; 664 665 /* The c_decode_option function and decode_option hook set 666 this to `2' if -Wall is used, so we can avoid giving out 667 lots of errors for people who don't realize what -Wall does. */ 668 if (warn_uninitialized == 1) 669 warning (OPT_Wuninitialized, 670 "-Wuninitialized is not supported without -O"); 671 } 672 673 if (flag_really_no_inline == 2) 674 flag_really_no_inline = flag_no_inline; 675 676 /* The optimization to partition hot and cold basic blocks into separate 677 sections of the .o and executable files does not work (currently) 678 with exception handling. This is because there is no support for 679 generating unwind info. If flag_exceptions is turned on we need to 680 turn off the partitioning optimization. */ 681 682 if (flag_exceptions && flag_reorder_blocks_and_partition) 683 { 684 inform 685 ("-freorder-blocks-and-partition does not work with exceptions"); 686 flag_reorder_blocks_and_partition = 0; 687 flag_reorder_blocks = 1; 688 } 689 690 /* If user requested unwind info, then turn off the partitioning 691 optimization. */ 692 693 if (flag_unwind_tables && ! targetm.unwind_tables_default 694 && flag_reorder_blocks_and_partition) 695 { 696 inform ("-freorder-blocks-and-partition does not support unwind info"); 697 flag_reorder_blocks_and_partition = 0; 698 flag_reorder_blocks = 1; 699 } 700 701 /* If the target requested unwind info, then turn off the partitioning 702 optimization with a different message. Likewise, if the target does not 703 support named sections. */ 704 705 if (flag_reorder_blocks_and_partition 706 && (!targetm.have_named_sections 707 || (flag_unwind_tables && targetm.unwind_tables_default))) 708 { 709 inform 710 ("-freorder-blocks-and-partition does not work on this architecture"); 711 flag_reorder_blocks_and_partition = 0; 712 flag_reorder_blocks = 1; 713 } 714} 715 716/* Handle target- and language-independent options. Return zero to 717 generate an "unknown option" message. Only options that need 718 extra handling need to be listed here; if you simply want 719 VALUE assigned to a variable, it happens automatically. */ 720 721static int 722common_handle_option (size_t scode, const char *arg, int value) 723{ 724 enum opt_code code = (enum opt_code) scode; 725 726 switch (code) 727 { 728 case OPT__help: 729 print_help (); 730 exit_after_options = true; 731 break; 732 733 case OPT__param: 734 handle_param (arg); 735 break; 736 737 case OPT__target_help: 738 print_target_help (); 739 exit_after_options = true; 740 break; 741 742 case OPT__version: 743 print_version (stderr, ""); 744 exit_after_options = true; 745 break; 746 747 case OPT_G: 748 g_switch_value = value; 749 g_switch_set = true; 750 break; 751 752 case OPT_O: 753 case OPT_Os: 754 /* Currently handled in a prescan. */ 755 break; 756 757 case OPT_W: 758 /* For backward compatibility, -W is the same as -Wextra. */ 759 set_Wextra (value); 760 break; 761 762 case OPT_Wextra: 763 set_Wextra (value); 764 break; 765 766 case OPT_Wlarger_than_: 767 larger_than_size = value; 768 warn_larger_than = value != -1; 769 break; 770 771 case OPT_Wstrict_aliasing: 772 case OPT_Wstrict_aliasing_: 773 warn_strict_aliasing = value; 774 break; 775 776 case OPT_Wunused: 777 set_Wunused (value); 778 break; 779 780 case OPT_aux_info: 781 case OPT_aux_info_: 782 aux_info_file_name = arg; 783 flag_gen_aux_info = 1; 784 break; 785 786 case OPT_auxbase: 787 aux_base_name = arg; 788 break; 789 790 case OPT_auxbase_strip: 791 { 792 char *tmp = xstrdup (arg); 793 strip_off_ending (tmp, strlen (tmp)); 794 if (tmp[0]) 795 aux_base_name = tmp; 796 } 797 break; 798 799 case OPT_d: 800 decode_d_option (arg); 801 break; 802 803 case OPT_dumpbase: 804 dump_base_name = arg; 805 break; 806 807 case OPT_falign_functions_: 808 align_functions = value; 809 break; 810 811 case OPT_falign_jumps_: 812 align_jumps = value; 813 break; 814 815 case OPT_falign_labels_: 816 align_labels = value; 817 break; 818 819 case OPT_falign_loops_: 820 align_loops = value; 821 break; 822 823 case OPT_fbranch_probabilities: 824 flag_branch_probabilities_set = true; 825 break; 826 827 case OPT_floop_optimize: 828 flag_loop_optimize_set = true; 829 break; 830 831 case OPT_fcall_used_: 832 fix_register (arg, 0, 1); 833 break; 834 835 case OPT_fcall_saved_: 836 fix_register (arg, 0, 0); 837 break; 838 839 case OPT_fdiagnostics_show_location_: 840 if (!strcmp (arg, "once")) 841 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE; 842 else if (!strcmp (arg, "every-line")) 843 diagnostic_prefixing_rule (global_dc) 844 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE; 845 else 846 return 0; 847 break; 848 849 case OPT_fdiagnostics_show_option: 850 global_dc->show_option_requested = true; 851 break; 852 853 case OPT_fdump_: 854 if (!dump_switch_p (arg)) 855 return 0; 856 break; 857 858 case OPT_ffast_math: 859 set_fast_math_flags (value); 860 break; 861 862 case OPT_ffixed_: 863 fix_register (arg, 1, 1); 864 break; 865 866 case OPT_finline_limit_: 867 case OPT_finline_limit_eq: 868 set_param_value ("max-inline-insns-single", value / 2); 869 set_param_value ("max-inline-insns-auto", value / 2); 870 break; 871 872 case OPT_fmessage_length_: 873 pp_set_line_maximum_length (global_dc->printer, value); 874 break; 875 876 case OPT_fpack_struct_: 877 if (value <= 0 || (value & (value - 1)) || value > 16) 878 error("structure alignment must be a small power of two, not %d", value); 879 else 880 { 881 initial_max_fld_align = value; 882 maximum_field_alignment = value * BITS_PER_UNIT; 883 } 884 break; 885 886 case OPT_fpeel_loops: 887 flag_peel_loops_set = true; 888 break; 889 890 case OPT_fprofile_arcs: 891 profile_arc_flag_set = true; 892 break; 893 894 case OPT_fprofile_use: 895 if (!flag_branch_probabilities_set) 896 flag_branch_probabilities = value; 897 if (!flag_profile_values_set) 898 flag_profile_values = value; 899 if (!flag_unroll_loops_set) 900 flag_unroll_loops = value; 901 if (!flag_peel_loops_set) 902 flag_peel_loops = value; 903 if (!flag_tracer_set) 904 flag_tracer = value; 905 if (!flag_value_profile_transformations_set) 906 flag_value_profile_transformations = value; 907 /* Old loop optimizer is incompatible with tree profiling. */ 908 if (!flag_loop_optimize_set) 909 flag_loop_optimize = 0; 910 break; 911 912 case OPT_fprofile_generate: 913 if (!profile_arc_flag_set) 914 profile_arc_flag = value; 915 if (!flag_profile_values_set) 916 flag_profile_values = value; 917 if (!flag_value_profile_transformations_set) 918 flag_value_profile_transformations = value; 919 break; 920 921 case OPT_fprofile_values: 922 flag_profile_values_set = true; 923 break; 924 925 case OPT_fvisibility_: 926 { 927 if (!strcmp(arg, "default")) 928 default_visibility = VISIBILITY_DEFAULT; 929 else if (!strcmp(arg, "internal")) 930 default_visibility = VISIBILITY_INTERNAL; 931 else if (!strcmp(arg, "hidden")) 932 default_visibility = VISIBILITY_HIDDEN; 933 else if (!strcmp(arg, "protected")) 934 default_visibility = VISIBILITY_PROTECTED; 935 else 936 error ("unrecognized visibility value \"%s\"", arg); 937 } 938 break; 939 940 case OPT_fvpt: 941 flag_value_profile_transformations_set = true; 942 break; 943 944 case OPT_frandom_seed: 945 /* The real switch is -fno-random-seed. */ 946 if (value) 947 return 0; 948 flag_random_seed = NULL; 949 break; 950 951 case OPT_frandom_seed_: 952 flag_random_seed = arg; 953 break; 954 955 case OPT_fsched_verbose_: 956#ifdef INSN_SCHEDULING 957 fix_sched_param ("verbose", arg); 958 break; 959#else 960 return 0; 961#endif 962 963 case OPT_fsched_stalled_insns_: 964 flag_sched_stalled_insns = value; 965 if (flag_sched_stalled_insns == 0) 966 flag_sched_stalled_insns = -1; 967 break; 968 969 case OPT_fsched_stalled_insns_dep_: 970 flag_sched_stalled_insns_dep = value; 971 break; 972 973 case OPT_fstack_limit: 974 /* The real switch is -fno-stack-limit. */ 975 if (value) 976 return 0; 977 stack_limit_rtx = NULL_RTX; 978 break; 979 980 case OPT_fstack_limit_register_: 981 { 982 int reg = decode_reg_name (arg); 983 if (reg < 0) 984 error ("unrecognized register name \"%s\"", arg); 985 else 986 stack_limit_rtx = gen_rtx_REG (Pmode, reg); 987 } 988 break; 989 990 case OPT_fstack_limit_symbol_: 991 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg)); 992 break; 993 994 case OPT_ftree_vectorizer_verbose_: 995 vect_set_verbosity_level (arg); 996 break; 997 998 case OPT_ftls_model_: 999 if (!strcmp (arg, "global-dynamic")) 1000 flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC; 1001 else if (!strcmp (arg, "local-dynamic")) 1002 flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC; 1003 else if (!strcmp (arg, "initial-exec")) 1004 flag_tls_default = TLS_MODEL_INITIAL_EXEC; 1005 else if (!strcmp (arg, "local-exec")) 1006 flag_tls_default = TLS_MODEL_LOCAL_EXEC; 1007 else 1008 warning (0, "unknown tls-model \"%s\"", arg); 1009 break; 1010 1011 case OPT_ftracer: 1012 flag_tracer_set = true; 1013 break; 1014 1015 case OPT_funroll_loops: 1016 flag_unroll_loops_set = true; 1017 break; 1018 1019 case OPT_g: 1020 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg); 1021 break; 1022 1023 case OPT_gcoff: 1024 set_debug_level (SDB_DEBUG, false, arg); 1025 break; 1026 1027 case OPT_gdwarf_2: 1028 set_debug_level (DWARF2_DEBUG, false, arg); 1029 break; 1030 1031 case OPT_ggdb: 1032 set_debug_level (NO_DEBUG, 2, arg); 1033 break; 1034 1035 case OPT_gstabs: 1036 case OPT_gstabs_: 1037 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg); 1038 break; 1039 1040 case OPT_gvms: 1041 set_debug_level (VMS_DEBUG, false, arg); 1042 break; 1043 1044 case OPT_gxcoff: 1045 case OPT_gxcoff_: 1046 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg); 1047 break; 1048 1049 case OPT_o: 1050 asm_file_name = arg; 1051 break; 1052 1053 case OPT_pedantic_errors: 1054 flag_pedantic_errors = pedantic = 1; 1055 break; 1056 1057 case OPT_fforce_mem: 1058 warning (0, "-f[no-]force-mem is nop and option will be removed in 4.2"); 1059 break; 1060 1061 default: 1062 /* If the flag was handled in a standard way, assume the lack of 1063 processing here is intentional. */ 1064 gcc_assert (cl_options[scode].flag_var); 1065 break; 1066 } 1067 1068 return 1; 1069} 1070 1071/* Handle --param NAME=VALUE. */ 1072static void 1073handle_param (const char *carg) 1074{ 1075 char *equal, *arg; 1076 int value; 1077 1078 arg = xstrdup (carg); 1079 equal = strchr (arg, '='); 1080 if (!equal) 1081 error ("%s: --param arguments should be of the form NAME=VALUE", arg); 1082 else 1083 { 1084 value = integral_argument (equal + 1); 1085 if (value == -1) 1086 error ("invalid --param value %qs", equal + 1); 1087 else 1088 { 1089 *equal = '\0'; 1090 set_param_value (arg, value); 1091 } 1092 } 1093 1094 free (arg); 1095} 1096 1097/* Handle -W and -Wextra. */ 1098static void 1099set_Wextra (int setting) 1100{ 1101 extra_warnings = setting; 1102 warn_unused_value = setting; 1103 warn_unused_parameter = (setting && maybe_warn_unused_parameter); 1104 1105 /* We save the value of warn_uninitialized, since if they put 1106 -Wuninitialized on the command line, we need to generate a 1107 warning about not using it without also specifying -O. */ 1108 if (setting == 0) 1109 warn_uninitialized = 0; 1110 else if (warn_uninitialized != 1) 1111 warn_uninitialized = 2; 1112} 1113 1114/* Initialize unused warning flags. */ 1115void 1116set_Wunused (int setting) 1117{ 1118 warn_unused_function = setting; 1119 warn_unused_label = setting; 1120 /* Unused function parameter warnings are reported when either 1121 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified. 1122 Thus, if -Wextra has already been seen, set warn_unused_parameter; 1123 otherwise set maybe_warn_extra_parameter, which will be picked up 1124 by set_Wextra. */ 1125 maybe_warn_unused_parameter = setting; 1126 warn_unused_parameter = (setting && extra_warnings); 1127 warn_unused_variable = setting; 1128 warn_unused_value = setting; 1129} 1130 1131/* The following routines are useful in setting all the flags that 1132 -ffast-math and -fno-fast-math imply. */ 1133void 1134set_fast_math_flags (int set) 1135{ 1136 flag_trapping_math = !set; 1137 flag_unsafe_math_optimizations = set; 1138 flag_finite_math_only = set; 1139 flag_errno_math = !set; 1140 if (set) 1141 { 1142 flag_signaling_nans = 0; 1143 flag_rounding_math = 0; 1144 flag_cx_limited_range = 1; 1145 } 1146} 1147 1148/* Return true iff flags are set as if -ffast-math. */ 1149bool 1150fast_math_flags_set_p (void) 1151{ 1152 return (!flag_trapping_math 1153 && flag_unsafe_math_optimizations 1154 && flag_finite_math_only 1155 && !flag_errno_math); 1156} 1157 1158/* Handle a debug output -g switch. EXTENDED is true or false to support 1159 extended output (2 is special and means "-ggdb" was given). */ 1160static void 1161set_debug_level (enum debug_info_type type, int extended, const char *arg) 1162{ 1163 static bool type_explicit; 1164 1165 use_gnu_debug_info_extensions = extended; 1166 1167 if (type == NO_DEBUG) 1168 { 1169 if (write_symbols == NO_DEBUG) 1170 { 1171 write_symbols = PREFERRED_DEBUGGING_TYPE; 1172 1173 if (extended == 2) 1174 { 1175#ifdef DWARF2_DEBUGGING_INFO 1176 write_symbols = DWARF2_DEBUG; 1177#elif defined DBX_DEBUGGING_INFO 1178 write_symbols = DBX_DEBUG; 1179#endif 1180 } 1181 1182 if (write_symbols == NO_DEBUG) 1183 warning (0, "target system does not support debug output"); 1184 } 1185 } 1186 else 1187 { 1188 /* Does it conflict with an already selected type? */ 1189 if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols) 1190 error ("debug format \"%s\" conflicts with prior selection", 1191 debug_type_names[type]); 1192 write_symbols = type; 1193 type_explicit = true; 1194 } 1195 1196 /* A debug flag without a level defaults to level 2. */ 1197 if (*arg == '\0') 1198 { 1199 if (!debug_info_level) 1200 debug_info_level = 2; 1201 } 1202 else 1203 { 1204 debug_info_level = integral_argument (arg); 1205 if (debug_info_level == (unsigned int) -1) 1206 error ("unrecognised debug output level \"%s\"", arg); 1207 else if (debug_info_level > 3) 1208 error ("debug output level %s is too high", arg); 1209 } 1210} 1211 1212/* Display help for target options. */ 1213static void 1214print_target_help (void) 1215{ 1216 unsigned int i; 1217 static bool displayed = false; 1218 1219 /* Avoid double printing for --help --target-help. */ 1220 if (displayed) 1221 return; 1222 1223 displayed = true; 1224 for (i = 0; i < cl_options_count; i++) 1225 if ((cl_options[i].flags & (CL_TARGET | CL_UNDOCUMENTED)) == CL_TARGET) 1226 { 1227 printf (_("\nTarget specific options:\n")); 1228 print_filtered_help (CL_TARGET); 1229 break; 1230 } 1231} 1232 1233/* Output --help text. */ 1234static void 1235print_help (void) 1236{ 1237 size_t i; 1238 const char *p; 1239 1240 GET_ENVIRONMENT (p, "COLUMNS"); 1241 if (p) 1242 { 1243 int value = atoi (p); 1244 if (value > 0) 1245 columns = value; 1246 } 1247 1248 puts (_("The following options are language-independent:\n")); 1249 1250 print_filtered_help (CL_COMMON); 1251 print_param_help (); 1252 1253 for (i = 0; lang_names[i]; i++) 1254 { 1255 printf (_("The %s front end recognizes the following options:\n\n"), 1256 lang_names[i]); 1257 print_filtered_help (1U << i); 1258 } 1259 print_target_help (); 1260} 1261 1262/* Print the help for --param. */ 1263static void 1264print_param_help (void) 1265{ 1266 size_t i; 1267 1268 puts (_("The --param option recognizes the following as parameters:\n")); 1269 1270 for (i = 0; i < LAST_PARAM; i++) 1271 { 1272 const char *help = compiler_params[i].help; 1273 const char *param = compiler_params[i].option; 1274 1275 if (help == NULL || *help == '\0') 1276 help = undocumented_msg; 1277 1278 /* Get the translation. */ 1279 help = _(help); 1280 1281 wrap_help (help, param, strlen (param)); 1282 } 1283 1284 putchar ('\n'); 1285} 1286 1287/* Print help for a specific front-end, etc. */ 1288static void 1289print_filtered_help (unsigned int flag) 1290{ 1291 unsigned int i, len, filter, indent = 0; 1292 bool duplicates = false; 1293 const char *help, *opt, *tab; 1294 static char *printed; 1295 1296 if (flag == CL_COMMON || flag == CL_TARGET) 1297 { 1298 filter = flag; 1299 if (!printed) 1300 printed = xmalloc (cl_options_count); 1301 memset (printed, 0, cl_options_count); 1302 } 1303 else 1304 { 1305 /* Don't print COMMON options twice. */ 1306 filter = flag | CL_COMMON; 1307 1308 for (i = 0; i < cl_options_count; i++) 1309 { 1310 if ((cl_options[i].flags & filter) != flag) 1311 continue; 1312 1313 /* Skip help for internal switches. */ 1314 if (cl_options[i].flags & CL_UNDOCUMENTED) 1315 continue; 1316 1317 /* Skip switches that have already been printed, mark them to be 1318 listed later. */ 1319 if (printed[i]) 1320 { 1321 duplicates = true; 1322 indent = print_switch (cl_options[i].opt_text, indent); 1323 } 1324 } 1325 1326 if (duplicates) 1327 { 1328 putchar ('\n'); 1329 putchar ('\n'); 1330 } 1331 } 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. */ 1343 if (printed[i]) 1344 continue; 1345 1346 printed[i] = true; 1347 1348 help = cl_options[i].help; 1349 if (!help) 1350 help = undocumented_msg; 1351 1352 /* Get the translation. */ 1353 help = _(help); 1354 1355 tab = strchr (help, '\t'); 1356 if (tab) 1357 { 1358 len = tab - help; 1359 opt = help; 1360 help = tab + 1; 1361 } 1362 else 1363 { 1364 opt = cl_options[i].opt_text; 1365 len = strlen (opt); 1366 } 1367 1368 wrap_help (help, opt, len); 1369 } 1370 1371 putchar ('\n'); 1372} 1373 1374/* Output ITEM, of length ITEM_WIDTH, in the left column, followed by 1375 word-wrapped HELP in a second column. */ 1376static unsigned int 1377print_switch (const char *text, unsigned int indent) 1378{ 1379 unsigned int len = strlen (text) + 1; /* trailing comma */ 1380 1381 if (indent) 1382 { 1383 putchar (','); 1384 if (indent + len > columns) 1385 { 1386 putchar ('\n'); 1387 putchar (' '); 1388 indent = 1; 1389 } 1390 } 1391 else 1392 putchar (' '); 1393 1394 putchar (' '); 1395 fputs (text, stdout); 1396 1397 return indent + len + 1; 1398} 1399 1400/* Output ITEM, of length ITEM_WIDTH, in the left column, followed by 1401 word-wrapped HELP in a second column. */ 1402static void 1403wrap_help (const char *help, const char *item, unsigned int item_width) 1404{ 1405 unsigned int col_width = 27; 1406 unsigned int remaining, room, len; 1407 1408 remaining = strlen (help); 1409 1410 do 1411 { 1412 room = columns - 3 - MAX (col_width, item_width); 1413 if (room > columns) 1414 room = 0; 1415 len = remaining; 1416 1417 if (room < len) 1418 { 1419 unsigned int i; 1420 1421 for (i = 0; help[i]; i++) 1422 { 1423 if (i >= room && len != remaining) 1424 break; 1425 if (help[i] == ' ') 1426 len = i; 1427 else if ((help[i] == '-' || help[i] == '/') 1428 && help[i + 1] != ' ' 1429 && i > 0 && ISALPHA (help[i - 1])) 1430 len = i + 1; 1431 } 1432 } 1433 1434 printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help); 1435 item_width = 0; 1436 while (help[len] == ' ') 1437 len++; 1438 help += len; 1439 remaining -= len; 1440 } 1441 while (remaining); 1442} 1443 1444/* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't 1445 a simple on-off switch. */ 1446 1447int 1448option_enabled (int opt_idx) 1449{ 1450 const struct cl_option *option = &(cl_options[opt_idx]); 1451 if (option->flag_var) 1452 switch (option->var_type) 1453 { 1454 case CLVC_BOOLEAN: 1455 return *(int *) option->flag_var != 0; 1456 1457 case CLVC_EQUAL: 1458 return *(int *) option->flag_var == option->var_value; 1459 1460 case CLVC_BIT_CLEAR: 1461 return (*(int *) option->flag_var & option->var_value) == 0; 1462 1463 case CLVC_BIT_SET: 1464 return (*(int *) option->flag_var & option->var_value) != 0; 1465 1466 case CLVC_STRING: 1467 break; 1468 } 1469 return -1; 1470} 1471 1472/* Fill STATE with the current state of option OPTION. Return true if 1473 there is some state to store. */ 1474 1475bool 1476get_option_state (int option, struct cl_option_state *state) 1477{ 1478 if (cl_options[option].flag_var == 0) 1479 return false; 1480 1481 switch (cl_options[option].var_type) 1482 { 1483 case CLVC_BOOLEAN: 1484 case CLVC_EQUAL: 1485 state->data = cl_options[option].flag_var; 1486 state->size = sizeof (int); 1487 break; 1488 1489 case CLVC_BIT_CLEAR: 1490 case CLVC_BIT_SET: 1491 state->ch = option_enabled (option); 1492 state->data = &state->ch; 1493 state->size = 1; 1494 break; 1495 1496 case CLVC_STRING: 1497 state->data = *(const char **) cl_options[option].flag_var; 1498 if (state->data == 0) 1499 state->data = ""; 1500 state->size = strlen (state->data) + 1; 1501 break; 1502 } 1503 return true; 1504} 1505