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