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