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 && write_symbols == DWARF2_DEBUG)
 651     {
 652       warning
 653         ("-freorder-blocks-and-partition does not work with -g (currently)");
 654       flag_reorder_blocks_and_partition = 0;
 655       flag_reorder_blocks = 1;
 656     }
 657 }
 658
 659 /* Handle target- and language-independent options.  Return zero to
 660    generate an "unknown option" message.  Only options that need
 661    extra handling need to be listed here; if you simply want
 662    VALUE assigned to a variable, it happens automatically.  */
 663
 664 static int
 665 common_handle_option (size_t scode, const char *arg, int value)
 666 {
 667   enum opt_code code = (enum opt_code) scode;
 668
 669   switch (code)
 670     {
 671     case OPT__help:
 672       print_help ();
 673       exit_after_options = true;
 674       break;
 675
 676     case OPT__param:
 677       handle_param (arg);
 678       break;
 679
 680     case OPT__target_help:
 681       display_target_options ();
 682       exit_after_options = true;
 683       break;
 684
 685     case OPT__version:
 686       print_version (stderr, "");
 687       exit_after_options = true;
 688       break;
 689
 690     case OPT_G:
 691       g_switch_value = value;
 692       g_switch_set = true;
 693       break;
 694
 695     case OPT_O:
 696     case OPT_Os:
 697       /* Currently handled in a prescan.  */
 698       break;
 699
 700     case OPT_W:
 701       /* For backward compatibility, -W is the same as -Wextra.  */
 702       set_Wextra (value);
 703       break;
 704
 705     case OPT_Wextra:
 706       set_Wextra (value);
 707       break;
 708
 709     case OPT_Wlarger_than_:
 710       larger_than_size = value;
 711       warn_larger_than = value != -1;
 712       break;
 713
 714     case OPT_Wstrict_aliasing:
 715     case OPT_Wstrict_aliasing_:
 716       warn_strict_aliasing = value;
 717       break;
 718
 719     case OPT_Wunused:
 720       set_Wunused (value);
 721       break;
 722
 723     case OPT_aux_info:
 724     case OPT_aux_info_:
 725       aux_info_file_name = arg;
 726       flag_gen_aux_info = 1;
 727       break;
 728
 729     case OPT_auxbase:
 730       aux_base_name = arg;
 731       break;
 732
 733     case OPT_auxbase_strip:
 734       {
 735         char *tmp = xstrdup (arg);
 736         strip_off_ending (tmp, strlen (tmp));
 737         if (tmp[0])
 738           aux_base_name = tmp;
 739       }
 740       break;
 741
 742     case OPT_d:
 743       decode_d_option (arg);
 744       break;
 745
 746     case OPT_dumpbase:
 747       dump_base_name = arg;
 748       break;
 749
 750     case OPT_falign_functions_:
 751       align_functions = value;
 752       break;
 753
 754     case OPT_falign_jumps_:
 755       align_jumps = value;
 756       break;
 757
 758     case OPT_falign_labels_:
 759       align_labels = value;
 760       break;
 761
 762     case OPT_falign_loops_:
 763       align_loops = value;
 764       break;
 765
 766     case OPT_fbranch_probabilities:
 767       flag_branch_probabilities_set = true;
 768       break;
 769
 770     case OPT_fcall_used_:
 771       fix_register (arg, 0, 1);
 772       break;
 773
 774     case OPT_fcall_saved_:
 775       fix_register (arg, 0, 0);
 776       break;
 777
 778     case OPT_fdiagnostics_show_location_:
 779       if (!strcmp (arg, "once"))
 780         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 781       else if (!strcmp (arg, "every-line"))
 782         diagnostic_prefixing_rule (global_dc)
 783           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
 784       else
 785         return 0;
 786       break;
 787
 788     case OPT_fdump_:
 789       if (!dump_switch_p (arg))
 790         return 0;
 791       break;
 792
 793     case OPT_ffast_math:
 794       set_fast_math_flags (value);
 795       break;
 796
 797     case OPT_ffixed_:
 798       fix_register (arg, 1, 1);
 799       break;
 800
 801     case OPT_finline_limit_:
 802     case OPT_finline_limit_eq:
 803       set_param_value ("max-inline-insns-single", value / 2);
 804       set_param_value ("max-inline-insns-auto", value / 2);
 805       set_param_value ("max-inline-insns-rtl", value);
 806       break;
 807
 808     case OPT_fmessage_length_:
 809       pp_set_line_maximum_length (global_dc->printer, value);
 810       break;
 811
 812     case OPT_fpeel_loops:
 813       flag_peel_loops_set = true;
 814       break;
 815
 816     case OPT_fprofile_arcs:
 817       profile_arc_flag_set = true;
 818       break;
 819
 820     case OPT_fprofile_use:
 821       if (!flag_branch_probabilities_set)
 822         flag_branch_probabilities = value;
 823       if (!flag_profile_values_set)
 824         flag_profile_values = value;
 825       if (!flag_unroll_loops_set)
 826         flag_unroll_loops = value;
 827       if (!flag_peel_loops_set)
 828         flag_peel_loops = value;
 829       if (!flag_tracer_set)
 830         flag_tracer = value;
 831       if (!flag_value_profile_transformations_set)
 832         flag_value_profile_transformations = value;
 833       break;
 834
 835     case OPT_fprofile_generate:
 836       if (!profile_arc_flag_set)
 837         profile_arc_flag = value;
 838       if (!flag_profile_values_set)
 839         flag_profile_values = value;
 840       if (!flag_value_profile_transformations_set)
 841         flag_value_profile_transformations = value;
 842       break;
 843
 844     case OPT_fprofile_values:
 845       flag_profile_values_set = true;
 846       break;
 847
 848     case OPT_fvisibility_:
 849       {
 850         if (!strcmp(arg, "default"))
 851           default_visibility = VISIBILITY_DEFAULT;
 852         else if (!strcmp(arg, "internal"))
 853           default_visibility = VISIBILITY_INTERNAL;
 854         else if (!strcmp(arg, "hidden"))
 855           default_visibility = VISIBILITY_HIDDEN;
 856         else if (!strcmp(arg, "protected"))
 857           default_visibility = VISIBILITY_PROTECTED;
 858         else
 859           error ("unrecognised visibility value \"%s\"", arg);
 860       }
 861       break;
 862
 863     case OPT_fvpt:
 864       flag_value_profile_transformations_set = value;
 865       break;
 866
 867     case OPT_frandom_seed:
 868       /* The real switch is -fno-random-seed.  */
 869       if (value)
 870         return 0;
 871       flag_random_seed = NULL;
 872       break;
 873
 874     case OPT_frandom_seed_:
 875       flag_random_seed = arg;
 876       break;
 877
 878     case OPT_fsched_verbose_:
 879 #ifdef INSN_SCHEDULING
 880       fix_sched_param ("verbose", arg);
 881       break;
 882 #else
 883       return 0;
 884 #endif
 885
 886     case OPT_fsched_stalled_insns_:
 887       flag_sched_stalled_insns = value;
 888       if (flag_sched_stalled_insns == 0)
 889         flag_sched_stalled_insns = -1;
 890       break;
 891
 892     case OPT_fsched_stalled_insns_dep_:
 893       flag_sched_stalled_insns_dep = value;
 894       break;
 895
 896     case OPT_fstack_limit:
 897       /* The real switch is -fno-stack-limit.  */
 898       if (value)
 899         return 0;
 900       stack_limit_rtx = NULL_RTX;
 901       break;
 902
 903     case OPT_fstack_limit_register_:
 904       {
 905         int reg = decode_reg_name (arg);
 906         if (reg < 0)
 907           error ("unrecognized register name \"%s\"", arg);
 908         else
 909           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
 910       }
 911       break;
 912
 913     case OPT_fstack_limit_symbol_:
 914       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
 915       break;
 916
 917     case OPT_ftls_model_:
 918       if (!strcmp (arg, "global-dynamic"))
 919         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
 920       else if (!strcmp (arg, "local-dynamic"))
 921         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
 922       else if (!strcmp (arg, "initial-exec"))
 923         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
 924       else if (!strcmp (arg, "local-exec"))
 925         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
 926       else
 927         warning ("unknown tls-model \"%s\"", arg);
 928       break;
 929
 930     case OPT_ftracer:
 931       flag_tracer_set = true;
 932       break;
 933
 934     case OPT_ftree_points_to_:
 935       if (!strcmp (arg, "andersen"))
 936 #ifdef HAVE_BANSHEE
 937         flag_tree_points_to = PTA_ANDERSEN;
 938 #else
 939         warning ("Andersen's PTA not available - libbanshee not compiled.");
 940 #endif
 941       else if (!strcmp (arg, "none"))
 942         flag_tree_points_to = PTA_NONE;
 943       else
 944         {
 945           warning ("`%s`: unknown points-to analysis algorithm", arg);
 946           return 0;
 947         }
 948       break;
 949
 950     case OPT_funroll_loops:
 951       flag_unroll_loops_set = true;
 952       break;
 953
 954     case OPT_g:
 955       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
 956       break;
 957
 958     case OPT_gcoff:
 959       set_debug_level (SDB_DEBUG, false, arg);
 960       break;
 961
 962     case OPT_gdwarf_2:
 963       set_debug_level (DWARF2_DEBUG, false, arg);
 964       break;
 965
 966     case OPT_ggdb:
 967       set_debug_level (NO_DEBUG, 2, arg);
 968       break;
 969
 970     case OPT_gstabs:
 971     case OPT_gstabs_:
 972       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
 973       break;
 974
 975     case OPT_gvms:
 976       set_debug_level (VMS_DEBUG, false, arg);
 977       break;
 978
 979     case OPT_gxcoff:
 980     case OPT_gxcoff_:
 981       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
 982       break;
 983
 984     case OPT_m:
 985       set_target_switch (arg);
 986       break;
 987
 988     case OPT_o:
 989       asm_file_name = arg;
 990       break;
 991
 992     case OPT_pedantic_errors:
 993       flag_pedantic_errors = pedantic = 1;
 994       break;
 995
 996     default:
 997       /* If the flag was handled in a standard way, assume the lack of
 998          processing here is intentional.  */
 999       if (cl_options[scode].flag_var)
1000         break;
1001
1002       abort ();
1003     }
1004
1005   return 1;
1006 }
1007
1008 /* Handle --param NAME=VALUE.  */
1009 static void
1010 handle_param (const char *carg)
1011 {
1012   char *equal, *arg;
1013   int value;
1014
1015   arg = xstrdup (carg);
1016   equal = strchr (arg, '=');
1017   if (!equal)
1018     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1019   else
1020     {
1021       value = integral_argument (equal + 1);
1022       if (value == -1)
1023         error ("invalid --param value `%s'", equal + 1);
1024       else
1025         {
1026           *equal = '\0';
1027           set_param_value (arg, value);
1028         }
1029     }
1030
1031   free (arg);
1032 }
1033
1034 /* Handle -W and -Wextra.  */
1035 static void
1036 set_Wextra (int setting)
1037 {
1038   extra_warnings = setting;
1039   warn_unused_value = setting;
1040   warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1041
1042   /* We save the value of warn_uninitialized, since if they put
1043      -Wuninitialized on the command line, we need to generate a
1044      warning about not using it without also specifying -O.  */
1045   if (setting == 0)
1046     warn_uninitialized = 0;
1047   else if (warn_uninitialized != 1)
1048     warn_uninitialized = 2;
1049 }
1050
1051 /* Initialize unused warning flags.  */
1052 void
1053 set_Wunused (int setting)
1054 {
1055   warn_unused_function = setting;
1056   warn_unused_label = setting;
1057   /* Unused function parameter warnings are reported when either
1058      ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1059      Thus, if -Wextra has already been seen, set warn_unused_parameter;
1060      otherwise set maybe_warn_extra_parameter, which will be picked up
1061      by set_Wextra.  */
1062   maybe_warn_unused_parameter = setting;
1063   warn_unused_parameter = (setting && extra_warnings);
1064   warn_unused_variable = setting;
1065   warn_unused_value = setting;
1066 }
1067
1068 /* The following routines are useful in setting all the flags that
1069    -ffast-math and -fno-fast-math imply.  */
1070 void
1071 set_fast_math_flags (int set)
1072 {
1073   flag_trapping_math = !set;
1074   flag_unsafe_math_optimizations = set;
1075   flag_finite_math_only = set;
1076   flag_errno_math = !set;
1077   if (set)
1078     {
1079       flag_signaling_nans = 0;
1080       flag_rounding_math = 0;
1081     }
1082 }
1083
1084 /* Return true iff flags are set as if -ffast-math.  */
1085 bool
1086 fast_math_flags_set_p (void)
1087 {
1088   return (!flag_trapping_math
1089           && flag_unsafe_math_optimizations
1090           && flag_finite_math_only
1091           && !flag_errno_math);
1092 }
1093
1094 /* Handle a debug output -g switch.  EXTENDED is true or false to support
1095    extended output (2 is special and means "-ggdb" was given).  */
1096 static void
1097 set_debug_level (enum debug_info_type type, int extended, const char *arg)
1098 {
1099   static bool type_explicit;
1100
1101   use_gnu_debug_info_extensions = extended;
1102
1103   if (type == NO_DEBUG)
1104     {
1105       if (write_symbols == NO_DEBUG)
1106         {
1107           write_symbols = PREFERRED_DEBUGGING_TYPE;
1108
1109           if (extended == 2)
1110             {
1111 #ifdef DWARF2_DEBUGGING_INFO
1112               write_symbols = DWARF2_DEBUG;
1113 #elif defined DBX_DEBUGGING_INFO
1114               write_symbols = DBX_DEBUG;
1115 #endif
1116             }
1117
1118           if (write_symbols == NO_DEBUG)
1119             warning ("target system does not support debug output");
1120         }
1121     }
1122   else
1123     {
1124       /* Does it conflict with an already selected type?  */
1125       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1126         error ("debug format \"%s\" conflicts with prior selection",
1127                debug_type_names[type]);
1128       write_symbols = type;
1129       type_explicit = true;
1130     }
1131
1132   /* A debug flag without a level defaults to level 2.  */
1133   if (*arg == '\0')
1134     {
1135       if (!debug_info_level)
1136         debug_info_level = 2;
1137     }
1138   else
1139     {
1140       debug_info_level = integral_argument (arg);
1141       if (debug_info_level == (unsigned int) -1)
1142         error ("unrecognised debug output level \"%s\"", arg);
1143       else if (debug_info_level > 3)
1144         error ("debug output level %s is too high", arg);
1145     }
1146 }
1147
1148 /* Output --help text.  */
1149 static void
1150 print_help (void)
1151 {
1152   size_t i;
1153   const char *p;
1154
1155   GET_ENVIRONMENT (p, "COLUMNS");
1156   if (p)
1157     {
1158       int value = atoi (p);
1159       if (value > 0)
1160         columns = value;
1161     }
1162
1163   puts (_("The following options are language-independent:\n"));
1164
1165   print_filtered_help (CL_COMMON);
1166   print_param_help ();
1167
1168   for (i = 0; lang_names[i]; i++)
1169     {
1170       printf (_("The %s front end recognizes the following options:\n\n"),
1171               lang_names[i]);
1172       print_filtered_help (1U << i);
1173     }
1174
1175   display_target_options ();
1176 }
1177
1178 /* Print the help for --param.  */
1179 static void
1180 print_param_help (void)
1181 {
1182   size_t i;
1183
1184   puts (_("The --param option recognizes the following as parameters:\n"));
1185
1186   for (i = 0; i < LAST_PARAM; i++)
1187     {
1188       const char *help = compiler_params[i].help;
1189       const char *param = compiler_params[i].option;
1190
1191       if (help == NULL || *help == '\0')
1192         help = undocumented_msg;
1193
1194       /* Get the translation.  */
1195       help = _(help);
1196
1197       wrap_help (help, param, strlen (param));
1198     }
1199
1200   putchar ('\n');
1201 }
1202
1203 /* Print help for a specific front-end, etc.  */
1204 static void
1205 print_filtered_help (unsigned int flag)
1206 {
1207   unsigned int i, len, filter, indent = 0;
1208   bool duplicates = false;
1209   const char *help, *opt, *tab;
1210   static char *printed;
1211
1212   if (flag == CL_COMMON)
1213     {
1214       filter = flag;
1215       if (!printed)
1216         printed = xmalloc (cl_options_count);
1217       memset (printed, 0, cl_options_count);
1218     }
1219   else
1220     {
1221       /* Don't print COMMON options twice.  */
1222       filter = flag | CL_COMMON;
1223
1224       for (i = 0; i < cl_options_count; i++)
1225         {
1226           if ((cl_options[i].flags & filter) != flag)
1227             continue;
1228
1229           /* Skip help for internal switches.  */
1230           if (cl_options[i].flags & CL_UNDOCUMENTED)
1231             continue;
1232
1233           /* Skip switches that have already been printed, mark them to be
1234              listed later.  */
1235           if (printed[i])
1236             {
1237               duplicates = true;
1238               indent = print_switch (cl_options[i].opt_text, indent);
1239             }
1240         }
1241
1242       if (duplicates)
1243         {
1244           putchar ('\n');
1245           putchar ('\n');
1246         }
1247     }
1248
1249   for (i = 0; i < cl_options_count; i++)
1250     {
1251       if ((cl_options[i].flags & filter) != flag)
1252         continue;
1253
1254       /* Skip help for internal switches.  */
1255       if (cl_options[i].flags & CL_UNDOCUMENTED)
1256         continue;
1257
1258       /* Skip switches that have already been printed.  */
1259       if (printed[i])
1260         continue;
1261
1262       printed[i] = true;
1263
1264       help = cl_options[i].help;
1265       if (!help)
1266         help = undocumented_msg;
1267
1268       /* Get the translation.  */
1269       help = _(help);
1270
1271       tab = strchr (help, '\t');
1272       if (tab)
1273         {
1274           len = tab - help;
1275           opt = help;
1276           help = tab + 1;
1277         }
1278       else
1279         {
1280           opt = cl_options[i].opt_text;
1281           len = strlen (opt);
1282         }
1283
1284       wrap_help (help, opt, len);
1285     }
1286
1287   putchar ('\n');
1288 }
1289
1290 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1291    word-wrapped HELP in a second column.  */
1292 static unsigned int
1293 print_switch (const char *text, unsigned int indent)
1294 {
1295   unsigned int len = strlen (text) + 1; /* trailing comma */
1296
1297   if (indent)
1298     {
1299       putchar (',');
1300       if (indent + len > columns)
1301         {
1302           putchar ('\n');
1303           putchar (' ');
1304           indent = 1;
1305         }
1306     }
1307   else
1308     putchar (' ');
1309
1310   putchar (' ');
1311   fputs (text, stdout);
1312
1313   return indent + len + 1;
1314 }
1315
1316 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1317    word-wrapped HELP in a second column.  */
1318 static void
1319 wrap_help (const char *help, const char *item, unsigned int item_width)
1320 {
1321   unsigned int col_width = 27;
1322   unsigned int remaining, room, len;
1323
1324   remaining = strlen (help);
1325
1326   do
1327     {
1328       room = columns - 3 - MAX (col_width, item_width);
1329       if (room > columns)
1330         room = 0;
1331       len = remaining;
1332
1333       if (room < len)
1334         {
1335           unsigned int i;
1336
1337           for (i = 0; help[i]; i++)
1338             {
1339               if (i >= room && len != remaining)
1340                 break;
1341               if (help[i] == ' ')
1342                 len = i;
1343               else if ((help[i] == '-' || help[i] == '/')
1344                        && help[i + 1] != ' '
1345                        && i > 0 && ISALPHA (help[i - 1]))
1346                 len = i + 1;
1347             }
1348         }
1349
1350       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1351       item_width = 0;
1352       while (help[len] == ' ')
1353         len++;
1354       help += len;
1355       remaining -= len;
1356     }
1357   while (remaining);
1358 }