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