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