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       flag_tree_fre = 1;
 499
 500       if (!optimize_size)
 501         {
 502           /* Loop header copying usually increases size of the code.  This used
 503              not to be true, since quite often it is possible to verify that
 504              the condition is satisfied in the first iteration and therefore
 505              to eliminate it.  Jump threading handles these cases now.  */
 506           flag_tree_ch = 1;
 507         }
 508     }
 509
 510   if (optimize >= 2)
 511     {
 512       flag_crossjumping = 1;
 513       flag_optimize_sibling_calls = 1;
 514       flag_cse_follow_jumps = 1;
 515       flag_cse_skip_blocks = 1;
 516       flag_gcse = 1;
 517       flag_expensive_optimizations = 1;
 518       flag_strength_reduce = 1;
 519       flag_rerun_cse_after_loop = 1;
 520       flag_rerun_loop_opt = 1;
 521       flag_caller_saves = 1;
 522       flag_force_mem = 1;
 523       flag_peephole2 = 1;
 524 #ifdef INSN_SCHEDULING
 525       flag_schedule_insns = 1;
 526       flag_schedule_insns_after_reload = 1;
 527 #endif
 528       flag_regmove = 1;
 529       flag_strict_aliasing = 1;
 530       flag_delete_null_pointer_checks = 1;
 531       flag_reorder_blocks = 1;
 532       flag_reorder_functions = 1;
 533       flag_unit_at_a_time = 1;
 534     }
 535
 536   if (optimize >= 3)
 537     {
 538       flag_inline_functions = 1;
 539       flag_unswitch_loops = 1;
 540       flag_gcse_after_reload = 1;
 541     }
 542
 543   if (optimize < 2 || optimize_size)
 544     {
 545       align_loops = 1;
 546       align_jumps = 1;
 547       align_labels = 1;
 548       align_functions = 1;
 549
 550       /* Don't reorder blocks when optimizing for size because extra
 551          jump insns may be created; also barrier may create extra padding.
 552
 553          More correctly we should have a block reordering mode that tried
 554          to minimize the combined size of all the jumps.  This would more
 555          or less automatically remove extra jumps, but would also try to
 556          use more short jumps instead of long jumps.  */
 557       flag_reorder_blocks = 0;
 558       flag_reorder_blocks_and_partition = 0;
 559     }
 560
 561   if (optimize_size)
 562     {
 563       /* Inlining of very small functions usually reduces total size.  */
 564       set_param_value ("max-inline-insns-single", 5);
 565       set_param_value ("max-inline-insns-auto", 5);
 566       set_param_value ("max-inline-insns-rtl", 10);
 567       flag_inline_functions = 1;
 568     }
 569
 570   /* Initialize whether `char' is signed.  */
 571   flag_signed_char = DEFAULT_SIGNED_CHAR;
 572   /* Set this to a special "uninitialized" value.  The actual default is set
 573      after target options have been processed.  */
 574   flag_short_enums = 2;
 575
 576   /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
 577      modify it.  */
 578   target_flags = 0;
 579   set_target_switch ("");
 580
 581   /* Unwind tables are always present in an ABI-conformant IA-64
 582      object file, so the default should be ON.  */
 583 #ifdef IA64_UNWIND_INFO
 584   flag_unwind_tables = IA64_UNWIND_INFO;
 585 #endif
 586
 587 #ifdef OPTIMIZATION_OPTIONS
 588   /* Allow default optimizations to be specified on a per-machine basis.  */
 589   OPTIMIZATION_OPTIONS (optimize, optimize_size);
 590 #endif
 591
 592   handle_options (argc, argv, lang_mask);
 593
 594   if (flag_pie)
 595     flag_pic = flag_pie;
 596   if (flag_pic && !flag_pie)
 597     flag_shlib = 1;
 598
 599   if (flag_no_inline == 2)
 600     flag_no_inline = 0;
 601   else
 602     flag_really_no_inline = flag_no_inline;
 603
 604   /* Set flag_no_inline before the post_options () hook.  The C front
 605      ends use it to determine tree inlining defaults.  FIXME: such
 606      code should be lang-independent when all front ends use tree
 607      inlining, in which case it, and this condition, should be moved
 608      to the top of process_options() instead.  */
 609   if (optimize == 0)
 610     {
 611       /* Inlining does not work if not optimizing,
 612          so force it not to be done.  */
 613       flag_no_inline = 1;
 614       warn_inline = 0;
 615
 616       /* The c_decode_option function and decode_option hook set
 617          this to `2' if -Wall is used, so we can avoid giving out
 618          lots of errors for people who don't realize what -Wall does.  */
 619       if (warn_uninitialized == 1)
 620         warning ("-Wuninitialized is not supported without -O");
 621     }
 622
 623   if (flag_really_no_inline == 2)
 624     flag_really_no_inline = flag_no_inline;
 625
 626   /* The optimization to partition hot and cold basic blocks into separate
 627      sections of the .o and executable files does not work (currently)
 628      with exception handling.  If flag_exceptions is turned on we need to
 629      turn off the partitioning optimization.  */
 630
 631   if (flag_exceptions && flag_reorder_blocks_and_partition)
 632     {
 633       warning
 634             ("-freorder-blocks-and-partition does not work with exceptions");
 635       flag_reorder_blocks_and_partition = 0;
 636       flag_reorder_blocks = 1;
 637     }
 638 }
 639
 640 /* Handle target- and language-independent options.  Return zero to
 641    generate an "unknown option" message.  Only options that need
 642    extra handling need to be listed here; if you simply want
 643    VALUE assigned to a variable, it happens automatically.  */
 644
 645 static int
 646 common_handle_option (size_t scode, const char *arg, int value)
 647 {
 648   enum opt_code code = (enum opt_code) scode;
 649
 650   switch (code)
 651     {
 652     case OPT__help:
 653       print_help ();
 654       exit_after_options = true;
 655       break;
 656
 657     case OPT__param:
 658       handle_param (arg);
 659       break;
 660
 661     case OPT__target_help:
 662       display_target_options ();
 663       exit_after_options = true;
 664       break;
 665
 666     case OPT__version:
 667       print_version (stderr, "");
 668       exit_after_options = true;
 669       break;
 670
 671     case OPT_G:
 672       g_switch_value = value;
 673       g_switch_set = true;
 674       break;
 675
 676     case OPT_O:
 677     case OPT_Os:
 678       /* Currently handled in a prescan.  */
 679       break;
 680
 681     case OPT_W:
 682       /* For backward compatibility, -W is the same as -Wextra.  */
 683       set_Wextra (value);
 684       break;
 685
 686     case OPT_Wextra:
 687       set_Wextra (value);
 688       break;
 689
 690     case OPT_Wlarger_than_:
 691       larger_than_size = value;
 692       warn_larger_than = value != -1;
 693       break;
 694
 695     case OPT_Wstrict_aliasing:
 696     case OPT_Wstrict_aliasing_:
 697       warn_strict_aliasing = value;
 698       break;
 699
 700     case OPT_Wunused:
 701       set_Wunused (value);
 702       break;
 703
 704     case OPT_aux_info:
 705     case OPT_aux_info_:
 706       aux_info_file_name = arg;
 707       flag_gen_aux_info = 1;
 708       break;
 709
 710     case OPT_auxbase:
 711       aux_base_name = arg;
 712       break;
 713
 714     case OPT_auxbase_strip:
 715       {
 716         char *tmp = xstrdup (arg);
 717         strip_off_ending (tmp, strlen (tmp));
 718         if (tmp[0])
 719           aux_base_name = tmp;
 720       }
 721       break;
 722
 723     case OPT_d:
 724       decode_d_option (arg);
 725       break;
 726
 727     case OPT_dumpbase:
 728       dump_base_name = arg;
 729       break;
 730
 731     case OPT_falign_functions_:
 732       align_functions = value;
 733       break;
 734
 735     case OPT_falign_jumps_:
 736       align_jumps = value;
 737       break;
 738
 739     case OPT_falign_labels_:
 740       align_labels = value;
 741       break;
 742
 743     case OPT_falign_loops_:
 744       align_loops = value;
 745       break;
 746
 747     case OPT_fbranch_probabilities:
 748       flag_branch_probabilities_set = true;
 749       break;
 750
 751     case OPT_fcall_used_:
 752       fix_register (arg, 0, 1);
 753       break;
 754
 755     case OPT_fcall_saved_:
 756       fix_register (arg, 0, 0);
 757       break;
 758
 759     case OPT_fdiagnostics_show_location_:
 760       if (!strcmp (arg, "once"))
 761         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 762       else if (!strcmp (arg, "every-line"))
 763         diagnostic_prefixing_rule (global_dc)
 764           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
 765       else
 766         return 0;
 767       break;
 768
 769     case OPT_fdump_:
 770       if (!dump_switch_p (arg))
 771         return 0;
 772       break;
 773
 774     case OPT_ffast_math:
 775       set_fast_math_flags (value);
 776       break;
 777
 778     case OPT_ffixed_:
 779       fix_register (arg, 1, 1);
 780       break;
 781
 782     case OPT_finline_limit_:
 783     case OPT_finline_limit_eq:
 784       set_param_value ("max-inline-insns-single", value / 2);
 785       set_param_value ("max-inline-insns-auto", value / 2);
 786       set_param_value ("max-inline-insns-rtl", value);
 787       break;
 788
 789     case OPT_fmessage_length_:
 790       pp_set_line_maximum_length (global_dc->printer, value);
 791       break;
 792
 793     case OPT_fpeel_loops:
 794       flag_peel_loops_set = true;
 795       break;
 796
 797     case OPT_fprofile_arcs:
 798       profile_arc_flag_set = true;
 799       break;
 800
 801     case OPT_fprofile_use:
 802       if (!flag_branch_probabilities_set)
 803         flag_branch_probabilities = value;
 804       if (!flag_profile_values_set)
 805         flag_profile_values = value;
 806       if (!flag_unroll_loops_set)
 807         flag_unroll_loops = value;
 808       if (!flag_peel_loops_set)
 809         flag_peel_loops = value;
 810       if (!flag_tracer_set)
 811         flag_tracer = value;
 812       if (!flag_value_profile_transformations_set)
 813         flag_value_profile_transformations = value;
 814       break;
 815
 816     case OPT_fprofile_generate:
 817       if (!profile_arc_flag_set)
 818         profile_arc_flag = value;
 819       if (!flag_profile_values_set)
 820         flag_profile_values = value;
 821       if (!flag_value_profile_transformations_set)
 822         flag_value_profile_transformations = value;
 823       break;
 824
 825     case OPT_fprofile_values:
 826       flag_profile_values_set = true;
 827       break;
 828
 829     case OPT_fvpt:
 830       flag_value_profile_transformations_set = value;
 831       break;
 832
 833     case OPT_frandom_seed:
 834       /* The real switch is -fno-random-seed.  */
 835       if (value)
 836         return 0;
 837       flag_random_seed = NULL;
 838       break;
 839
 840     case OPT_frandom_seed_:
 841       flag_random_seed = arg;
 842       break;
 843
 844     case OPT_fsched_verbose_:
 845 #ifdef INSN_SCHEDULING
 846       fix_sched_param ("verbose", arg);
 847       break;
 848 #else
 849       return 0;
 850 #endif
 851
 852     case OPT_fsched_stalled_insns_:
 853       flag_sched_stalled_insns = value;
 854       if (flag_sched_stalled_insns == 0)
 855         flag_sched_stalled_insns = -1;
 856       break;
 857
 858     case OPT_fsched_stalled_insns_dep_:
 859       flag_sched_stalled_insns_dep = value;
 860       break;
 861
 862     case OPT_fstack_limit:
 863       /* The real switch is -fno-stack-limit.  */
 864       if (value)
 865         return 0;
 866       stack_limit_rtx = NULL_RTX;
 867       break;
 868
 869     case OPT_fstack_limit_register_:
 870       {
 871         int reg = decode_reg_name (arg);
 872         if (reg < 0)
 873           error ("unrecognized register name \"%s\"", arg);
 874         else
 875           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
 876       }
 877       break;
 878
 879     case OPT_fstack_limit_symbol_:
 880       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
 881       break;
 882
 883     case OPT_ftls_model_:
 884       if (!strcmp (arg, "global-dynamic"))
 885         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
 886       else if (!strcmp (arg, "local-dynamic"))
 887         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
 888       else if (!strcmp (arg, "initial-exec"))
 889         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
 890       else if (!strcmp (arg, "local-exec"))
 891         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
 892       else
 893         warning ("unknown tls-model \"%s\"", arg);
 894       break;
 895
 896     case OPT_ftracer:
 897       flag_tracer_set = true;
 898       break;
 899
 900     case OPT_ftree_points_to_:
 901       if (!strcmp (arg, "andersen"))
 902 #ifdef HAVE_BANSHEE
 903         flag_tree_points_to = PTA_ANDERSEN;
 904 #else
 905         warning ("Andersen's PTA not available - libbanshee not compiled.");
 906 #endif
 907       else if (!strcmp (arg, "none"))
 908         flag_tree_points_to = PTA_NONE;
 909       else
 910         {
 911           warning ("`%s`: unknown points-to analysis algorithm", arg);
 912           return 0;
 913         }
 914       break;
 915
 916     case OPT_funroll_loops:
 917       flag_unroll_loops_set = true;
 918       break;
 919
 920     case OPT_g:
 921       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
 922       break;
 923
 924     case OPT_gcoff:
 925       set_debug_level (SDB_DEBUG, false, arg);
 926       break;
 927
 928     case OPT_gdwarf_2:
 929       set_debug_level (DWARF2_DEBUG, false, arg);
 930       break;
 931
 932     case OPT_ggdb:
 933       set_debug_level (NO_DEBUG, 2, arg);
 934       break;
 935
 936     case OPT_gstabs:
 937     case OPT_gstabs_:
 938       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
 939       break;
 940
 941     case OPT_gvms:
 942       set_debug_level (VMS_DEBUG, false, arg);
 943       break;
 944
 945     case OPT_gxcoff:
 946     case OPT_gxcoff_:
 947       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
 948       break;
 949
 950     case OPT_m:
 951       set_target_switch (arg);
 952       break;
 953
 954     case OPT_o:
 955       asm_file_name = arg;
 956       break;
 957
 958     case OPT_pedantic_errors:
 959       flag_pedantic_errors = pedantic = 1;
 960       break;
 961
 962     default:
 963       /* If the flag was handled in a standard way, assume the lack of
 964          processing here is intentional.  */
 965       if (cl_options[scode].flag_var)
 966         break;
 967
 968       abort ();
 969     }
 970
 971   return 1;
 972 }
 973
 974 /* Handle --param NAME=VALUE.  */
 975 static void
 976 handle_param (const char *carg)
 977 {
 978   char *equal, *arg;
 979   int value;
 980
 981   arg = xstrdup (carg);
 982   equal = strchr (arg, '=');
 983   if (!equal)
 984     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
 985   else
 986     {
 987       value = integral_argument (equal + 1);
 988       if (value == -1)
 989         error ("invalid --param value `%s'", equal + 1);
 990       else
 991         {
 992           *equal = '\0';
 993           set_param_value (arg, value);
 994         }
 995     }
 996
 997   free (arg);
 998 }
 999
1000 /* Handle -W and -Wextra.  */
1001 static void
1002 set_Wextra (int setting)
1003 {
1004   extra_warnings = setting;
1005   warn_unused_value = setting;
1006   warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1007
1008   /* We save the value of warn_uninitialized, since if they put
1009      -Wuninitialized on the command line, we need to generate a
1010      warning about not using it without also specifying -O.  */
1011   if (setting == 0)
1012     warn_uninitialized = 0;
1013   else if (warn_uninitialized != 1)
1014     warn_uninitialized = 2;
1015 }
1016
1017 /* Initialize unused warning flags.  */
1018 void
1019 set_Wunused (int setting)
1020 {
1021   warn_unused_function = setting;
1022   warn_unused_label = setting;
1023   /* Unused function parameter warnings are reported when either
1024      ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1025      Thus, if -Wextra has already been seen, set warn_unused_parameter;
1026      otherwise set maybe_warn_extra_parameter, which will be picked up
1027      by set_Wextra.  */
1028   maybe_warn_unused_parameter = setting;
1029   warn_unused_parameter = (setting && extra_warnings);
1030   warn_unused_variable = setting;
1031   warn_unused_value = setting;
1032 }
1033
1034 /* The following routines are useful in setting all the flags that
1035    -ffast-math and -fno-fast-math imply.  */
1036 void
1037 set_fast_math_flags (int set)
1038 {
1039   flag_trapping_math = !set;
1040   flag_unsafe_math_optimizations = set;
1041   flag_finite_math_only = set;
1042   flag_errno_math = !set;
1043   if (set)
1044     {
1045       flag_signaling_nans = 0;
1046       flag_rounding_math = 0;
1047     }
1048 }
1049
1050 /* Return true iff flags are set as if -ffast-math.  */
1051 bool
1052 fast_math_flags_set_p (void)
1053 {
1054   return (!flag_trapping_math
1055           && flag_unsafe_math_optimizations
1056           && flag_finite_math_only
1057           && !flag_errno_math);
1058 }
1059
1060 /* Handle a debug output -g switch.  EXTENDED is true or false to support
1061    extended output (2 is special and means "-ggdb" was given).  */
1062 static void
1063 set_debug_level (enum debug_info_type type, int extended, const char *arg)
1064 {
1065   static bool type_explicit;
1066
1067   use_gnu_debug_info_extensions = extended;
1068
1069   if (type == NO_DEBUG)
1070     {
1071       if (write_symbols == NO_DEBUG)
1072         {
1073           write_symbols = PREFERRED_DEBUGGING_TYPE;
1074
1075           if (extended == 2)
1076             {
1077 #ifdef DWARF2_DEBUGGING_INFO
1078               write_symbols = DWARF2_DEBUG;
1079 #elif defined DBX_DEBUGGING_INFO
1080               write_symbols = DBX_DEBUG;
1081 #endif
1082             }
1083
1084           if (write_symbols == NO_DEBUG)
1085             warning ("target system does not support debug output");
1086         }
1087     }
1088   else
1089     {
1090       /* Does it conflict with an already selected type?  */
1091       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1092         error ("debug format \"%s\" conflicts with prior selection",
1093                debug_type_names[type]);
1094       write_symbols = type;
1095       type_explicit = true;
1096     }
1097
1098   /* A debug flag without a level defaults to level 2.  */
1099   if (*arg == '\0')
1100     {
1101       if (!debug_info_level)
1102         debug_info_level = 2;
1103     }
1104   else
1105     {
1106       debug_info_level = integral_argument (arg);
1107       if (debug_info_level == (unsigned int) -1)
1108         error ("unrecognised debug output level \"%s\"", arg);
1109       else if (debug_info_level > 3)
1110         error ("debug output level %s is too high", arg);
1111     }
1112 }
1113
1114 /* Output --help text.  */
1115 static void
1116 print_help (void)
1117 {
1118   size_t i;
1119   const char *p;
1120
1121   GET_ENVIRONMENT (p, "COLUMNS");
1122   if (p)
1123     {
1124       int value = atoi (p);
1125       if (value > 0)
1126         columns = value;
1127     }
1128
1129   puts (_("The following options are language-independent:\n"));
1130
1131   print_filtered_help (CL_COMMON);
1132   print_param_help ();
1133
1134   for (i = 0; lang_names[i]; i++)
1135     {
1136       printf (_("The %s front end recognizes the following options:\n\n"),
1137               lang_names[i]);
1138       print_filtered_help (1U << i);
1139     }
1140
1141   display_target_options ();
1142 }
1143
1144 /* Print the help for --param.  */
1145 static void
1146 print_param_help (void)
1147 {
1148   size_t i;
1149
1150   puts (_("The --param option recognizes the following as parameters:\n"));
1151
1152   for (i = 0; i < LAST_PARAM; i++)
1153     {
1154       const char *help = compiler_params[i].help;
1155       const char *param = compiler_params[i].option;
1156
1157       if (help == NULL || *help == '\0')
1158         help = undocumented_msg;
1159
1160       /* Get the translation.  */
1161       help = _(help);
1162
1163       wrap_help (help, param, strlen (param));
1164     }
1165
1166   putchar ('\n');
1167 }
1168
1169 /* Print help for a specific front-end, etc.  */
1170 static void
1171 print_filtered_help (unsigned int flag)
1172 {
1173   unsigned int i, len, filter, indent = 0;
1174   bool duplicates = false;
1175   const char *help, *opt, *tab;
1176   static char *printed;
1177
1178   if (flag == CL_COMMON)
1179     {
1180       filter = flag;
1181       if (!printed)
1182         printed = xmalloc (cl_options_count);
1183       memset (printed, 0, cl_options_count);
1184     }
1185   else
1186     {
1187       /* Don't print COMMON options twice.  */
1188       filter = flag | CL_COMMON;
1189
1190       for (i = 0; i < cl_options_count; i++)
1191         {
1192           if ((cl_options[i].flags & filter) != flag)
1193             continue;
1194
1195           /* Skip help for internal switches.  */
1196           if (cl_options[i].flags & CL_UNDOCUMENTED)
1197             continue;
1198
1199           /* Skip switches that have already been printed, mark them to be
1200              listed later.  */
1201           if (printed[i])
1202             {
1203               duplicates = true;
1204               indent = print_switch (cl_options[i].opt_text, indent);
1205             }
1206         }
1207
1208       if (duplicates)
1209         {
1210           putchar ('\n');
1211           putchar ('\n');
1212         }
1213     }
1214
1215   for (i = 0; i < cl_options_count; i++)
1216     {
1217       if ((cl_options[i].flags & filter) != flag)
1218         continue;
1219
1220       /* Skip help for internal switches.  */
1221       if (cl_options[i].flags & CL_UNDOCUMENTED)
1222         continue;
1223
1224       /* Skip switches that have already been printed.  */
1225       if (printed[i])
1226         continue;
1227
1228       printed[i] = true;
1229
1230       help = cl_options[i].help;
1231       if (!help)
1232         help = undocumented_msg;
1233
1234       /* Get the translation.  */
1235       help = _(help);
1236
1237       tab = strchr (help, '\t');
1238       if (tab)
1239         {
1240           len = tab - help;
1241           opt = help;
1242           help = tab + 1;
1243         }
1244       else
1245         {
1246           opt = cl_options[i].opt_text;
1247           len = strlen (opt);
1248         }
1249
1250       wrap_help (help, opt, len);
1251     }
1252
1253   putchar ('\n');
1254 }
1255
1256 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1257    word-wrapped HELP in a second column.  */
1258 static unsigned int
1259 print_switch (const char *text, unsigned int indent)
1260 {
1261   unsigned int len = strlen (text) + 1; /* trailing comma */
1262
1263   if (indent)
1264     {
1265       putchar (',');
1266       if (indent + len > columns)
1267         {
1268           putchar ('\n');
1269           putchar (' ');
1270           indent = 1;
1271         }
1272     }
1273   else
1274     putchar (' ');
1275
1276   putchar (' ');
1277   fputs (text, stdout);
1278
1279   return indent + len + 1;
1280 }
1281
1282 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1283    word-wrapped HELP in a second column.  */
1284 static void
1285 wrap_help (const char *help, const char *item, unsigned int item_width)
1286 {
1287   unsigned int col_width = 27;
1288   unsigned int remaining, room, len;
1289
1290   remaining = strlen (help);
1291
1292   do
1293     {
1294       room = columns - 3 - MAX (col_width, item_width);
1295       if (room > columns)
1296         room = 0;
1297       len = remaining;
1298
1299       if (room < len)
1300         {
1301           unsigned int i;
1302
1303           for (i = 0; help[i]; i++)
1304             {
1305               if (i >= room && len != remaining)
1306                 break;
1307               if (help[i] == ' ')
1308                 len = i;
1309               else if ((help[i] == '-' || help[i] == '/')
1310                        && help[i + 1] != ' '
1311                        && i > 0 && ISALPHA (help[i - 1]))
1312                 len = i + 1;
1313             }
1314         }
1315
1316       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1317       item_width = 0;
1318       while (help[len] == ' ')
1319         len++;
1320       help += len;
1321       remaining -= len;
1322     }
1323   while (remaining);
1324 }