gcc/opts.c

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