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