gcc/opts.c

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