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