gcc/opts.c

   1 /* Command line option handling.
   2    Copyright (C) 2002, 2003, 2004 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 this switch a prefix of the input?  */
 180       if (!strncmp (input, opt->opt_text + 1, opt->opt_len))
 181         {
 182           /* If language is OK, and the match is exact or the switch
 183              takes a joined argument, return it.  */
 184           if ((opt->flags & lang_mask)
 185               && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
 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 /* Decode and handle the vector of command line options.  LANG_MASK
 391    contains has a single bit set representing the current
 392    language.  */
 393 static void
 394 handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
 395 {
 396   unsigned int n, i;
 397
 398   for (i = 1; i < argc; i += n)
 399     {
 400       const char *opt = argv[i];
 401
 402       /* Interpret "-" or a non-switch as a file name.  */
 403       if (opt[0] != '-' || opt[1] == '\0')
 404         {
 405           if (main_input_filename == NULL)
 406             main_input_filename = opt;
 407           add_input_filename (opt);
 408           n = 1;
 409           continue;
 410         }
 411
 412       n = handle_option (argv + i, lang_mask);
 413
 414       if (!n)
 415         {
 416           n = 1;
 417           error ("unrecognized command line option \"%s\"", opt);
 418         }
 419     }
 420 }
 421
 422 /* Handle FILENAME from the command line.  */
 423 void
 424 add_input_filename (const char *filename)
 425 {
 426   num_in_fnames++;
 427   in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0]));
 428   in_fnames[num_in_fnames - 1] = filename;
 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       flag_thread_jumps = 1;
 485 #ifdef DELAY_SLOTS
 486       flag_delayed_branch = 1;
 487 #endif
 488 #ifdef CAN_DEBUG_WITHOUT_FP
 489       flag_omit_frame_pointer = 1;
 490 #endif
 491       flag_guess_branch_prob = 1;
 492       flag_cprop_registers = 1;
 493       flag_loop_optimize = 1;
 494       flag_if_conversion = 1;
 495       flag_if_conversion2 = 1;
 496       flag_tree_ccp = 1;
 497       flag_tree_dce = 1;
 498       flag_tree_dom = 1;
 499       flag_tree_dse = 1;
 500       flag_tree_ter = 1;
 501       flag_tree_live_range_split = 1;
 502       flag_tree_sra = 1;
 503       flag_tree_copyrename = 1;
 504       flag_tree_fre = 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           /* PRE tends to generate bigger code.  */
 515           flag_tree_pre = 1;
 516         }
 517     }
 518
 519   if (optimize >= 2)
 520     {
 521       flag_crossjumping = 1;
 522       flag_optimize_sibling_calls = 1;
 523       flag_cse_follow_jumps = 1;
 524       flag_cse_skip_blocks = 1;
 525       flag_gcse = 1;
 526       flag_expensive_optimizations = 1;
 527       flag_strength_reduce = 1;
 528       flag_rerun_cse_after_loop = 1;
 529       flag_rerun_loop_opt = 1;
 530       flag_caller_saves = 1;
 531       flag_force_mem = 1;
 532       flag_peephole2 = 1;
 533 #ifdef INSN_SCHEDULING
 534       flag_schedule_insns = 1;
 535       flag_schedule_insns_after_reload = 1;
 536 #endif
 537       flag_regmove = 1;
 538       flag_strict_aliasing = 1;
 539       flag_delete_null_pointer_checks = 1;
 540       flag_reorder_blocks = 1;
 541       flag_reorder_functions = 1;
 542       flag_unit_at_a_time = 1;
 543     }
 544
 545   if (optimize >= 3)
 546     {
 547       flag_inline_functions = 1;
 548       flag_unswitch_loops = 1;
 549       flag_gcse_after_reload = 1;
 550     }
 551
 552   if (optimize < 2 || optimize_size)
 553     {
 554       align_loops = 1;
 555       align_jumps = 1;
 556       align_labels = 1;
 557       align_functions = 1;
 558
 559       /* Don't reorder blocks when optimizing for size because extra
 560          jump insns may be created; also barrier may create extra padding.
 561
 562          More correctly we should have a block reordering mode that tried
 563          to minimize the combined size of all the jumps.  This would more
 564          or less automatically remove extra jumps, but would also try to
 565          use more short jumps instead of long jumps.  */
 566       flag_reorder_blocks = 0;
 567       flag_reorder_blocks_and_partition = 0;
 568     }
 569
 570   if (optimize_size)
 571     {
 572       /* Inlining of very small functions usually reduces total size.  */
 573       set_param_value ("max-inline-insns-single", 5);
 574       set_param_value ("max-inline-insns-auto", 5);
 575       set_param_value ("max-inline-insns-rtl", 10);
 576       flag_inline_functions = 1;
 577
 578       /* We want to crossjump as much as possible.  */
 579       set_param_value ("min-crossjump-insns", 1);
 580     }
 581
 582   /* Initialize whether `char' is signed.  */
 583   flag_signed_char = DEFAULT_SIGNED_CHAR;
 584   /* Set this to a special "uninitialized" value.  The actual default is set
 585      after target options have been processed.  */
 586   flag_short_enums = 2;
 587
 588   /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
 589      modify it.  */
 590   target_flags = 0;
 591   set_target_switch ("");
 592
 593   /* Unwind tables are always present when a target has ABI-specified unwind
 594      tables, so the default should be ON.  */
 595 #ifdef TARGET_UNWIND_INFO
 596   flag_unwind_tables = TARGET_UNWIND_INFO;
 597 #endif
 598
 599 #ifdef OPTIMIZATION_OPTIONS
 600   /* Allow default optimizations to be specified on a per-machine basis.  */
 601   OPTIMIZATION_OPTIONS (optimize, optimize_size);
 602 #endif
 603
 604   handle_options (argc, argv, lang_mask);
 605
 606   if (flag_pie)
 607     flag_pic = flag_pie;
 608   if (flag_pic && !flag_pie)
 609     flag_shlib = 1;
 610
 611   if (flag_no_inline == 2)
 612     flag_no_inline = 0;
 613   else
 614     flag_really_no_inline = flag_no_inline;
 615
 616   /* Set flag_no_inline before the post_options () hook.  The C front
 617      ends use it to determine tree inlining defaults.  FIXME: such
 618      code should be lang-independent when all front ends use tree
 619      inlining, in which case it, and this condition, should be moved
 620      to the top of process_options() instead.  */
 621   if (optimize == 0)
 622     {
 623       /* Inlining does not work if not optimizing,
 624          so force it not to be done.  */
 625       flag_no_inline = 1;
 626       warn_inline = 0;
 627
 628       /* The c_decode_option function and decode_option hook set
 629          this to `2' if -Wall is used, so we can avoid giving out
 630          lots of errors for people who don't realize what -Wall does.  */
 631       if (warn_uninitialized == 1)
 632         warning ("-Wuninitialized is not supported without -O");
 633     }
 634
 635   if (flag_really_no_inline == 2)
 636     flag_really_no_inline = flag_no_inline;
 637
 638   /* The optimization to partition hot and cold basic blocks into separate
 639      sections of the .o and executable files does not work (currently)
 640      with exception handling.  If flag_exceptions is turned on we need to
 641      turn off the partitioning optimization.  */
 642
 643   if (flag_exceptions && flag_reorder_blocks_and_partition)
 644     {
 645       warning
 646             ("-freorder-blocks-and-partition does not work with exceptions");
 647       flag_reorder_blocks_and_partition = 0;
 648       flag_reorder_blocks = 1;
 649     }
 650
 651   /* The optimization to partition hot and cold basic blocks into
 652      separate sections of the .o and executable files does not currently
 653      work correctly with DWARF debugging turned on.  Until this is fixed
 654      we will disable the optimization when DWARF debugging is set.  */
 655
 656   if (flag_reorder_blocks_and_partition && write_symbols == DWARF2_DEBUG)
 657     {
 658       warning
 659         ("-freorder-blocks-and-partition does not work with -g (currently)");
 660       flag_reorder_blocks_and_partition = 0;
 661       flag_reorder_blocks = 1;
 662     }
 663 }
 664
 665 /* Handle target- and language-independent options.  Return zero to
 666    generate an "unknown option" message.  Only options that need
 667    extra handling need to be listed here; if you simply want
 668    VALUE assigned to a variable, it happens automatically.  */
 669
 670 static int
 671 common_handle_option (size_t scode, const char *arg, int value)
 672 {
 673   enum opt_code code = (enum opt_code) scode;
 674
 675   switch (code)
 676     {
 677     case OPT__help:
 678       print_help ();
 679       exit_after_options = true;
 680       break;
 681
 682     case OPT__param:
 683       handle_param (arg);
 684       break;
 685
 686     case OPT__target_help:
 687       display_target_options ();
 688       exit_after_options = true;
 689       break;
 690
 691     case OPT__version:
 692       print_version (stderr, "");
 693       exit_after_options = true;
 694       break;
 695
 696     case OPT_G:
 697       g_switch_value = value;
 698       g_switch_set = true;
 699       break;
 700
 701     case OPT_O:
 702     case OPT_Os:
 703       /* Currently handled in a prescan.  */
 704       break;
 705
 706     case OPT_W:
 707       /* For backward compatibility, -W is the same as -Wextra.  */
 708       set_Wextra (value);
 709       break;
 710
 711     case OPT_Wextra:
 712       set_Wextra (value);
 713       break;
 714
 715     case OPT_Wlarger_than_:
 716       larger_than_size = value;
 717       warn_larger_than = value != -1;
 718       break;
 719
 720     case OPT_Wstrict_aliasing:
 721     case OPT_Wstrict_aliasing_:
 722       warn_strict_aliasing = value;
 723       break;
 724
 725     case OPT_Wunused:
 726       set_Wunused (value);
 727       break;
 728
 729     case OPT_aux_info:
 730     case OPT_aux_info_:
 731       aux_info_file_name = arg;
 732       flag_gen_aux_info = 1;
 733       break;
 734
 735     case OPT_auxbase:
 736       aux_base_name = arg;
 737       break;
 738
 739     case OPT_auxbase_strip:
 740       {
 741         char *tmp = xstrdup (arg);
 742         strip_off_ending (tmp, strlen (tmp));
 743         if (tmp[0])
 744           aux_base_name = tmp;
 745       }
 746       break;
 747
 748     case OPT_d:
 749       decode_d_option (arg);
 750       break;
 751
 752     case OPT_dumpbase:
 753       dump_base_name = arg;
 754       break;
 755
 756     case OPT_falign_functions_:
 757       align_functions = value;
 758       break;
 759
 760     case OPT_falign_jumps_:
 761       align_jumps = value;
 762       break;
 763
 764     case OPT_falign_labels_:
 765       align_labels = value;
 766       break;
 767
 768     case OPT_falign_loops_:
 769       align_loops = value;
 770       break;
 771
 772     case OPT_fbranch_probabilities:
 773       flag_branch_probabilities_set = true;
 774       break;
 775
 776     case OPT_fcall_used_:
 777       fix_register (arg, 0, 1);
 778       break;
 779
 780     case OPT_fcall_saved_:
 781       fix_register (arg, 0, 0);
 782       break;
 783
 784     case OPT_fdiagnostics_show_location_:
 785       if (!strcmp (arg, "once"))
 786         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 787       else if (!strcmp (arg, "every-line"))
 788         diagnostic_prefixing_rule (global_dc)
 789           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
 790       else
 791         return 0;
 792       break;
 793
 794     case OPT_fdump_:
 795       if (!dump_switch_p (arg))
 796         return 0;
 797       break;
 798
 799     case OPT_ffast_math:
 800       set_fast_math_flags (value);
 801       break;
 802
 803     case OPT_ffixed_:
 804       fix_register (arg, 1, 1);
 805       break;
 806
 807     case OPT_finline_limit_:
 808     case OPT_finline_limit_eq:
 809       set_param_value ("max-inline-insns-single", value / 2);
 810       set_param_value ("max-inline-insns-auto", value / 2);
 811       set_param_value ("max-inline-insns-rtl", value);
 812       break;
 813
 814     case OPT_fmessage_length_:
 815       pp_set_line_maximum_length (global_dc->printer, value);
 816       break;
 817
 818     case OPT_fpack_struct_:
 819       if (value <= 0 || (value & (value - 1)) || value > 16)
 820         error("structure alignment must be a small power of two, not %d", value);
 821       else
 822         {
 823           initial_max_fld_align = value;
 824           maximum_field_alignment = value * BITS_PER_UNIT;
 825         }
 826       break;
 827
 828     case OPT_fpeel_loops:
 829       flag_peel_loops_set = true;
 830       break;
 831
 832     case OPT_fprofile_arcs:
 833       profile_arc_flag_set = true;
 834       break;
 835
 836     case OPT_fprofile_use:
 837       if (!flag_branch_probabilities_set)
 838         flag_branch_probabilities = value;
 839       if (!flag_profile_values_set)
 840         flag_profile_values = value;
 841       if (!flag_unroll_loops_set)
 842         flag_unroll_loops = value;
 843       if (!flag_peel_loops_set)
 844         flag_peel_loops = value;
 845       if (!flag_tracer_set)
 846         flag_tracer = value;
 847       if (!flag_value_profile_transformations_set)
 848         flag_value_profile_transformations = value;
 849 #ifdef HAVE_prefetch
 850       if (0 && !flag_speculative_prefetching_set)
 851         flag_speculative_prefetching = value;
 852 #endif
 853       break;
 854
 855     case OPT_fprofile_generate:
 856       if (!profile_arc_flag_set)
 857         profile_arc_flag = value;
 858       if (!flag_profile_values_set)
 859         flag_profile_values = value;
 860       if (!flag_value_profile_transformations_set)
 861         flag_value_profile_transformations = value;
 862       if (!flag_unroll_loops_set)
 863         flag_unroll_loops = value;
 864 #ifdef HAVE_prefetch
 865       if (0 && !flag_speculative_prefetching_set)
 866         flag_speculative_prefetching = value;
 867 #endif
 868       break;
 869
 870     case OPT_fprofile_values:
 871       flag_profile_values_set = true;
 872       break;
 873
 874     case OPT_fvisibility_:
 875       {
 876         if (!strcmp(arg, "default"))
 877           default_visibility = VISIBILITY_DEFAULT;
 878         else if (!strcmp(arg, "internal"))
 879           default_visibility = VISIBILITY_INTERNAL;
 880         else if (!strcmp(arg, "hidden"))
 881           default_visibility = VISIBILITY_HIDDEN;
 882         else if (!strcmp(arg, "protected"))
 883           default_visibility = VISIBILITY_PROTECTED;
 884         else
 885           error ("unrecognised visibility value \"%s\"", arg);
 886       }
 887       break;
 888
 889     case OPT_fvpt:
 890       flag_value_profile_transformations_set = true;
 891       break;
 892
 893     case OPT_fspeculative_prefetching:
 894       flag_speculative_prefetching_set = true;
 895       break;
 896
 897     case OPT_frandom_seed:
 898       /* The real switch is -fno-random-seed.  */
 899       if (value)
 900         return 0;
 901       flag_random_seed = NULL;
 902       break;
 903
 904     case OPT_frandom_seed_:
 905       flag_random_seed = arg;
 906       break;
 907
 908     case OPT_fsched_verbose_:
 909 #ifdef INSN_SCHEDULING
 910       fix_sched_param ("verbose", arg);
 911       break;
 912 #else
 913       return 0;
 914 #endif
 915
 916     case OPT_fsched_stalled_insns_:
 917       flag_sched_stalled_insns = value;
 918       if (flag_sched_stalled_insns == 0)
 919         flag_sched_stalled_insns = -1;
 920       break;
 921
 922     case OPT_fsched_stalled_insns_dep_:
 923       flag_sched_stalled_insns_dep = value;
 924       break;
 925
 926     case OPT_fstack_limit:
 927       /* The real switch is -fno-stack-limit.  */
 928       if (value)
 929         return 0;
 930       stack_limit_rtx = NULL_RTX;
 931       break;
 932
 933     case OPT_fstack_limit_register_:
 934       {
 935         int reg = decode_reg_name (arg);
 936         if (reg < 0)
 937           error ("unrecognized register name \"%s\"", arg);
 938         else
 939           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
 940       }
 941       break;
 942
 943     case OPT_fstack_limit_symbol_:
 944       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
 945       break;
 946
 947     case OPT_ftls_model_:
 948       if (!strcmp (arg, "global-dynamic"))
 949         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
 950       else if (!strcmp (arg, "local-dynamic"))
 951         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
 952       else if (!strcmp (arg, "initial-exec"))
 953         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
 954       else if (!strcmp (arg, "local-exec"))
 955         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
 956       else
 957         warning ("unknown tls-model \"%s\"", arg);
 958       break;
 959
 960     case OPT_ftracer:
 961       flag_tracer_set = true;
 962       break;
 963
 964     case OPT_funroll_loops:
 965       flag_unroll_loops_set = true;
 966       break;
 967
 968     case OPT_g:
 969       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
 970       break;
 971
 972     case OPT_gcoff:
 973       set_debug_level (SDB_DEBUG, false, arg);
 974       break;
 975
 976     case OPT_gdwarf_2:
 977       set_debug_level (DWARF2_DEBUG, false, arg);
 978       break;
 979
 980     case OPT_ggdb:
 981       set_debug_level (NO_DEBUG, 2, arg);
 982       break;
 983
 984     case OPT_gstabs:
 985     case OPT_gstabs_:
 986       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
 987       break;
 988
 989     case OPT_gvms:
 990       set_debug_level (VMS_DEBUG, false, arg);
 991       break;
 992
 993     case OPT_gxcoff:
 994     case OPT_gxcoff_:
 995       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
 996       break;
 997
 998     case OPT_m:
 999       set_target_switch (arg);
1000       break;
1001
1002     case OPT_o:
1003       asm_file_name = arg;
1004       break;
1005
1006     case OPT_pedantic_errors:
1007       flag_pedantic_errors = pedantic = 1;
1008       break;
1009
1010     default:
1011       /* If the flag was handled in a standard way, assume the lack of
1012          processing here is intentional.  */
1013       if (cl_options[scode].flag_var)
1014         break;
1015
1016       abort ();
1017     }
1018
1019   return 1;
1020 }
1021
1022 /* Handle --param NAME=VALUE.  */
1023 static void
1024 handle_param (const char *carg)
1025 {
1026   char *equal, *arg;
1027   int value;
1028
1029   arg = xstrdup (carg);
1030   equal = strchr (arg, '=');
1031   if (!equal)
1032     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1033   else
1034     {
1035       value = integral_argument (equal + 1);
1036       if (value == -1)
1037         error ("invalid --param value %qs", equal + 1);
1038       else
1039         {
1040           *equal = '\0';
1041           set_param_value (arg, value);
1042         }
1043     }
1044
1045   free (arg);
1046 }
1047
1048 /* Handle -W and -Wextra.  */
1049 static void
1050 set_Wextra (int setting)
1051 {
1052   extra_warnings = setting;
1053   warn_unused_value = setting;
1054   warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1055
1056   /* We save the value of warn_uninitialized, since if they put
1057      -Wuninitialized on the command line, we need to generate a
1058      warning about not using it without also specifying -O.  */
1059   if (setting == 0)
1060     warn_uninitialized = 0;
1061   else if (warn_uninitialized != 1)
1062     warn_uninitialized = 2;
1063 }
1064
1065 /* Initialize unused warning flags.  */
1066 void
1067 set_Wunused (int setting)
1068 {
1069   warn_unused_function = setting;
1070   warn_unused_label = setting;
1071   /* Unused function parameter warnings are reported when either
1072      ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1073      Thus, if -Wextra has already been seen, set warn_unused_parameter;
1074      otherwise set maybe_warn_extra_parameter, which will be picked up
1075      by set_Wextra.  */
1076   maybe_warn_unused_parameter = setting;
1077   warn_unused_parameter = (setting && extra_warnings);
1078   warn_unused_variable = setting;
1079   warn_unused_value = setting;
1080 }
1081
1082 /* The following routines are useful in setting all the flags that
1083    -ffast-math and -fno-fast-math imply.  */
1084 void
1085 set_fast_math_flags (int set)
1086 {
1087   flag_trapping_math = !set;
1088   flag_unsafe_math_optimizations = set;
1089   flag_finite_math_only = set;
1090   flag_errno_math = !set;
1091   if (set)
1092     {
1093       flag_signaling_nans = 0;
1094       flag_rounding_math = 0;
1095     }
1096 }
1097
1098 /* Return true iff flags are set as if -ffast-math.  */
1099 bool
1100 fast_math_flags_set_p (void)
1101 {
1102   return (!flag_trapping_math
1103           && flag_unsafe_math_optimizations
1104           && flag_finite_math_only
1105           && !flag_errno_math);
1106 }
1107
1108 /* Handle a debug output -g switch.  EXTENDED is true or false to support
1109    extended output (2 is special and means "-ggdb" was given).  */
1110 static void
1111 set_debug_level (enum debug_info_type type, int extended, const char *arg)
1112 {
1113   static bool type_explicit;
1114
1115   use_gnu_debug_info_extensions = extended;
1116
1117   if (type == NO_DEBUG)
1118     {
1119       if (write_symbols == NO_DEBUG)
1120         {
1121           write_symbols = PREFERRED_DEBUGGING_TYPE;
1122
1123           if (extended == 2)
1124             {
1125 #ifdef DWARF2_DEBUGGING_INFO
1126               write_symbols = DWARF2_DEBUG;
1127 #elif defined DBX_DEBUGGING_INFO
1128               write_symbols = DBX_DEBUG;
1129 #endif
1130             }
1131
1132           if (write_symbols == NO_DEBUG)
1133             warning ("target system does not support debug output");
1134         }
1135     }
1136   else
1137     {
1138       /* Does it conflict with an already selected type?  */
1139       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1140         error ("debug format \"%s\" conflicts with prior selection",
1141                debug_type_names[type]);
1142       write_symbols = type;
1143       type_explicit = true;
1144     }
1145
1146   /* A debug flag without a level defaults to level 2.  */
1147   if (*arg == '\0')
1148     {
1149       if (!debug_info_level)
1150         debug_info_level = 2;
1151     }
1152   else
1153     {
1154       debug_info_level = integral_argument (arg);
1155       if (debug_info_level == (unsigned int) -1)
1156         error ("unrecognised debug output level \"%s\"", arg);
1157       else if (debug_info_level > 3)
1158         error ("debug output level %s is too high", arg);
1159     }
1160 }
1161
1162 /* Output --help text.  */
1163 static void
1164 print_help (void)
1165 {
1166   size_t i;
1167   const char *p;
1168
1169   GET_ENVIRONMENT (p, "COLUMNS");
1170   if (p)
1171     {
1172       int value = atoi (p);
1173       if (value > 0)
1174         columns = value;
1175     }
1176
1177   puts (_("The following options are language-independent:\n"));
1178
1179   print_filtered_help (CL_COMMON);
1180   print_param_help ();
1181
1182   for (i = 0; lang_names[i]; i++)
1183     {
1184       printf (_("The %s front end recognizes the following options:\n\n"),
1185               lang_names[i]);
1186       print_filtered_help (1U << i);
1187     }
1188
1189   display_target_options ();
1190 }
1191
1192 /* Print the help for --param.  */
1193 static void
1194 print_param_help (void)
1195 {
1196   size_t i;
1197
1198   puts (_("The --param option recognizes the following as parameters:\n"));
1199
1200   for (i = 0; i < LAST_PARAM; i++)
1201     {
1202       const char *help = compiler_params[i].help;
1203       const char *param = compiler_params[i].option;
1204
1205       if (help == NULL || *help == '\0')
1206         help = undocumented_msg;
1207
1208       /* Get the translation.  */
1209       help = _(help);
1210
1211       wrap_help (help, param, strlen (param));
1212     }
1213
1214   putchar ('\n');
1215 }
1216
1217 /* Print help for a specific front-end, etc.  */
1218 static void
1219 print_filtered_help (unsigned int flag)
1220 {
1221   unsigned int i, len, filter, indent = 0;
1222   bool duplicates = false;
1223   const char *help, *opt, *tab;
1224   static char *printed;
1225
1226   if (flag == CL_COMMON)
1227     {
1228       filter = flag;
1229       if (!printed)
1230         printed = xmalloc (cl_options_count);
1231       memset (printed, 0, cl_options_count);
1232     }
1233   else
1234     {
1235       /* Don't print COMMON options twice.  */
1236       filter = flag | CL_COMMON;
1237
1238       for (i = 0; i < cl_options_count; i++)
1239         {
1240           if ((cl_options[i].flags & filter) != flag)
1241             continue;
1242
1243           /* Skip help for internal switches.  */
1244           if (cl_options[i].flags & CL_UNDOCUMENTED)
1245             continue;
1246
1247           /* Skip switches that have already been printed, mark them to be
1248              listed later.  */
1249           if (printed[i])
1250             {
1251               duplicates = true;
1252               indent = print_switch (cl_options[i].opt_text, indent);
1253             }
1254         }
1255
1256       if (duplicates)
1257         {
1258           putchar ('\n');
1259           putchar ('\n');
1260         }
1261     }
1262
1263   for (i = 0; i < cl_options_count; i++)
1264     {
1265       if ((cl_options[i].flags & filter) != flag)
1266         continue;
1267
1268       /* Skip help for internal switches.  */
1269       if (cl_options[i].flags & CL_UNDOCUMENTED)
1270         continue;
1271
1272       /* Skip switches that have already been printed.  */
1273       if (printed[i])
1274         continue;
1275
1276       printed[i] = true;
1277
1278       help = cl_options[i].help;
1279       if (!help)
1280         help = undocumented_msg;
1281
1282       /* Get the translation.  */
1283       help = _(help);
1284
1285       tab = strchr (help, '\t');
1286       if (tab)
1287         {
1288           len = tab - help;
1289           opt = help;
1290           help = tab + 1;
1291         }
1292       else
1293         {
1294           opt = cl_options[i].opt_text;
1295           len = strlen (opt);
1296         }
1297
1298       wrap_help (help, opt, len);
1299     }
1300
1301   putchar ('\n');
1302 }
1303
1304 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1305    word-wrapped HELP in a second column.  */
1306 static unsigned int
1307 print_switch (const char *text, unsigned int indent)
1308 {
1309   unsigned int len = strlen (text) + 1; /* trailing comma */
1310
1311   if (indent)
1312     {
1313       putchar (',');
1314       if (indent + len > columns)
1315         {
1316           putchar ('\n');
1317           putchar (' ');
1318           indent = 1;
1319         }
1320     }
1321   else
1322     putchar (' ');
1323
1324   putchar (' ');
1325   fputs (text, stdout);
1326
1327   return indent + len + 1;
1328 }
1329
1330 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1331    word-wrapped HELP in a second column.  */
1332 static void
1333 wrap_help (const char *help, const char *item, unsigned int item_width)
1334 {
1335   unsigned int col_width = 27;
1336   unsigned int remaining, room, len;
1337
1338   remaining = strlen (help);
1339
1340   do
1341     {
1342       room = columns - 3 - MAX (col_width, item_width);
1343       if (room > columns)
1344         room = 0;
1345       len = remaining;
1346
1347       if (room < len)
1348         {
1349           unsigned int i;
1350
1351           for (i = 0; help[i]; i++)
1352             {
1353               if (i >= room && len != remaining)
1354                 break;
1355               if (help[i] == ' ')
1356                 len = i;
1357               else if ((help[i] == '-' || help[i] == '/')
1358                        && help[i + 1] != ' '
1359                        && i > 0 && ISALPHA (help[i - 1]))
1360                 len = i + 1;
1361             }
1362         }
1363
1364       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1365       item_width = 0;
1366       while (help[len] == ' ')
1367         len++;
1368       help += len;
1369       remaining -= len;
1370     }
1371   while (remaining);
1372 }