gcc/opts.c

   1 /* Command line option handling.
   2    Copyright (C) 2002, 2003 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
  41 /* Value of the -G xx switch, and whether it was passed or not.  */
  42 unsigned HOST_WIDE_INT g_switch_value;
  43 bool g_switch_set;
  44
  45 /* True if we should exit after parsing options.  */
  46 bool exit_after_options;
  47
  48 /* If -version.  */
  49 bool version_flag;
  50
  51 /* Print various extra warnings.  -W/-Wextra.  */
  52 bool extra_warnings;
  53
  54 /* Don't print warning messages.  -w.  */
  55 bool inhibit_warnings;
  56
  57 /* Treat warnings as errors.  -Werror.  */
  58 bool warnings_are_errors;
  59
  60 /* Warn if a function returns an aggregate, since there are often
  61    incompatible calling conventions for doing this.  */
  62 bool warn_aggregate_return;
  63
  64 /* Nonzero means warn about pointer casts that increase the required
  65    alignment of the target type (and might therefore lead to a crash
  66    due to a misaligned access).  */
  67 bool warn_cast_align;
  68
  69 /* Nonzero means warn about uses of __attribute__((deprecated))
  70    declarations.  */
  71 bool warn_deprecated_decl = true;
  72
  73 /* Warn when an optimization pass is disabled.  */
  74 bool warn_disabled_optimization;
  75
  76 /* Nonzero means warn if inline function is too large.  */
  77 bool warn_inline;
  78
  79 /* True to warn about any objects definitions whose size is larger
  80    than N bytes.  Also want about function definitions whose returned
  81    values are larger than N bytes, where N is `larger_than_size'.  */
  82 bool warn_larger_than;
  83 HOST_WIDE_INT larger_than_size;
  84
  85 /* Warn about functions which might be candidates for attribute noreturn.  */
  86 bool warn_missing_noreturn;
  87
  88 /* True to warn about code which is never reached.  */
  89 bool warn_notreached;
  90
  91 /* Warn if packed attribute on struct is unnecessary and inefficient.  */
  92 bool warn_packed;
  93
  94 /* Warn when gcc pads a structure to an alignment boundary.  */
  95 bool warn_padded;
  96
  97 /* True means warn about all declarations which shadow others.  */
  98 bool warn_shadow;
  99
 100 /* Nonzero means warn about constructs which might not be
 101    strict-aliasing safe.  */
 102 bool warn_strict_aliasing;
 103
 104 /* True to warn if a switch on an enum, that does not have a default
 105    case, fails to have a case for every enum value.  */
 106 bool warn_switch;
 107
 108 /* Warn if a switch does not have a default case.  */
 109 bool warn_switch_default;
 110
 111 /* Warn if a switch on an enum fails to have a case for every enum
 112    value (regardless of the presence or otherwise of a default case).  */
 113 bool warn_switch_enum;
 114
 115 /* Don't suppress warnings from system headers.  -Wsystem-headers.  */
 116 bool warn_system_headers;
 117
 118 /* True to warn about variables used before they are initialized.  */
 119 int warn_uninitialized;
 120
 121 /* True to warn about unused variables, functions et.al.  */
 122 bool warn_unused_function;
 123 bool warn_unused_label;
 124 bool warn_unused_parameter;
 125 bool warn_unused_variable;
 126 bool warn_unused_value;
 127
 128 /* Hack for cooperation between set_Wunused and set_Wextra.  */
 129 static bool maybe_warn_unused_parameter;
 130
 131 /* Type(s) of debugging information we are producing (if any).  See
 132    flags.h for the definitions of the different possible types of
 133    debugging information.  */
 134 enum debug_info_type write_symbols = NO_DEBUG;
 135
 136 /* Level of debugging information we are producing.  See flags.h for
 137    the definitions of the different possible levels.  */
 138 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
 139
 140 /* Nonzero means use GNU-only extensions in the generated symbolic
 141    debugging information.  Currently, this only has an effect when
 142    write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG.  */
 143 bool use_gnu_debug_info_extensions;
 144
 145 /* Columns of --help display.  */
 146 static unsigned int columns = 80;
 147
 148 /* What to print when a switch has no documentation.  */
 149 static const char undocumented_msg[] = N_("This switch lacks documentation");
 150
 151 /* Used for bookkeeping on whether user set these flags so
 152    -fprofile-use/-fprofile-generate does not use them.  */
 153 static bool profile_arc_flag_set, flag_profile_values_set;
 154 static bool flag_unroll_loops_set, flag_tracer_set;
 155 static bool flag_value_profile_transformations_set;
 156 static bool flag_peel_loops_set, flag_branch_probabilities_set;
 157
 158 /* Input file names.  */
 159 const char **in_fnames;
 160 unsigned num_in_fnames;
 161
 162 static size_t find_opt (const char *, int);
 163 static int common_handle_option (size_t scode, const char *arg, int value);
 164 static void handle_param (const char *);
 165 static void set_Wextra (int);
 166 static unsigned int handle_option (const char **argv, unsigned int lang_mask);
 167 static char *write_langs (unsigned int lang_mask);
 168 static void complain_wrong_lang (const char *, const struct cl_option *,
 169                                  unsigned int lang_mask);
 170 static void handle_options (unsigned int, const char **, unsigned int);
 171 static void wrap_help (const char *help, const char *item, unsigned int);
 172 static void print_help (void);
 173 static void print_param_help (void);
 174 static void print_filtered_help (unsigned int flag);
 175 static unsigned int print_switch (const char *text, unsigned int indent);
 176 static void set_debug_level (enum debug_info_type type, int extended,
 177                              const char *arg);
 178
 179 /* Perform a binary search to find which option the command-line INPUT
 180    matches.  Returns its index in the option array, and N_OPTS
 181    (cl_options_count) on failure.
 182
 183    This routine is quite subtle.  A normal binary search is not good
 184    enough because some options can be suffixed with an argument, and
 185    multiple sub-matches can occur, e.g. input of "-pedantic" matching
 186    the initial substring of "-pedantic-errors".
 187
 188    A more complicated example is -gstabs.  It should match "-g" with
 189    an argument of "stabs".  Suppose, however, that the number and list
 190    of switches are such that the binary search tests "-gen-decls"
 191    before having tested "-g".  This doesn't match, and as "-gen-decls"
 192    is less than "-gstabs", it will become the lower bound of the
 193    binary search range, and "-g" will never be seen.  To resolve this
 194    issue, opts.sh makes "-gen-decls" point, via the back_chain member,
 195    to "-g" so that failed searches that end between "-gen-decls" and
 196    the lexicographically subsequent switch know to go back and see if
 197    "-g" causes a match (which it does in this example).
 198
 199    This search is done in such a way that the longest match for the
 200    front end in question wins.  If there is no match for the current
 201    front end, the longest match for a different front end is returned
 202    (or N_OPTS if none) and the caller emits an error message.  */
 203 static size_t
 204 find_opt (const char *input, int lang_mask)
 205 {
 206   size_t mn, mx, md, opt_len;
 207   size_t match_wrong_lang;
 208   int comp;
 209
 210   mn = 0;
 211   mx = cl_options_count;
 212
 213   /* Find mn such this lexicographical inequality holds:
 214      cl_options[mn] <= input < cl_options[mn + 1].  */
 215   while (mx - mn > 1)
 216     {
 217       md = (mn + mx) / 2;
 218       opt_len = cl_options[md].opt_len;
 219       comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
 220
 221       if (comp < 0)
 222         mx = md;
 223       else
 224         mn = md;
 225     }
 226
 227   /* This is the switch that is the best match but for a different
 228      front end, or cl_options_count if there is no match at all.  */
 229   match_wrong_lang = cl_options_count;
 230
 231   /* Backtrace the chain of possible matches, returning the longest
 232      one, if any, that fits best.  With current GCC switches, this
 233      loop executes at most twice.  */
 234   do
 235     {
 236       const struct cl_option *opt = &cl_options[mn];
 237
 238       /* Is this switch a prefix of the input?  */
 239       if (!strncmp (input, opt->opt_text + 1, opt->opt_len))
 240         {
 241           /* If language is OK, and the match is exact or the switch
 242              takes a joined argument, return it.  */
 243           if ((opt->flags & lang_mask)
 244               && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
 245             return mn;
 246
 247           /* If we haven't remembered a prior match, remember this
 248              one.  Any prior match is necessarily better.  */
 249           if (match_wrong_lang == cl_options_count)
 250             match_wrong_lang = mn;
 251         }
 252
 253       /* Try the next possibility.  This is cl_options_count if there
 254          are no more.  */
 255       mn = opt->back_chain;
 256     }
 257   while (mn != cl_options_count);
 258
 259   /* Return the best wrong match, or cl_options_count if none.  */
 260   return match_wrong_lang;
 261 }
 262
 263 /* If ARG is a non-negative integer made up solely of digits, return its
 264    value, otherwise return -1.  */
 265 static int
 266 integral_argument (const char *arg)
 267 {
 268   const char *p = arg;
 269
 270   while (*p && ISDIGIT (*p))
 271     p++;
 272
 273   if (*p == '\0')
 274     return atoi (arg);
 275
 276   return -1;
 277 }
 278
 279 /* Return a malloced slash-separated list of languages in MASK.  */
 280 static char *
 281 write_langs (unsigned int mask)
 282 {
 283   unsigned int n = 0, len = 0;
 284   const char *lang_name;
 285   char *result;
 286
 287   for (n = 0; (lang_name = lang_names[n]) != 0; n++)
 288     if (mask & (1U << n))
 289       len += strlen (lang_name) + 1;
 290
 291   result = xmalloc (len);
 292   len = 0;
 293   for (n = 0; (lang_name = lang_names[n]) != 0; n++)
 294     if (mask & (1U << n))
 295       {
 296         if (len)
 297           result[len++] = '/';
 298         strcpy (result + len, lang_name);
 299         len += strlen (lang_name);
 300       }
 301
 302   result[len] = 0;
 303
 304   return result;
 305 }
 306
 307 /* Complain that switch OPT_INDEX does not apply to this front end.  */
 308 static void
 309 complain_wrong_lang (const char *text, const struct cl_option *option,
 310                      unsigned int lang_mask)
 311 {
 312   char *ok_langs, *bad_lang;
 313
 314   ok_langs = write_langs (option->flags);
 315   bad_lang = write_langs (lang_mask);
 316
 317   /* Eventually this should become a hard error IMO.  */
 318   warning ("command line option \"%s\" is valid for %s but not for %s",
 319            text, ok_langs, bad_lang);
 320
 321   free (ok_langs);
 322   free (bad_lang);
 323 }
 324
 325 /* Handle the switch beginning at ARGV for the language indicated by
 326    LANG_MASK.  Returns the number of switches consumed.  */
 327 static unsigned int
 328 handle_option (const char **argv, unsigned int lang_mask)
 329 {
 330   size_t opt_index;
 331   const char *opt, *arg = 0;
 332   char *dup = 0;
 333   int value = 1;
 334   unsigned int result = 0;
 335   const struct cl_option *option;
 336
 337   opt = argv[0];
 338
 339   /* Drop the "no-" from negative switches.  */
 340   if ((opt[1] == 'W' || opt[1] == 'f')
 341       && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
 342     {
 343       size_t len = strlen (opt) - 3;
 344
 345       dup = xmalloc (len + 1);
 346       dup[0] = '-';
 347       dup[1] = opt[1];
 348       memcpy (dup + 2, opt + 5, len - 2 + 1);
 349       opt = dup;
 350       value = 0;
 351     }
 352
 353   opt_index = find_opt (opt + 1, lang_mask | CL_COMMON);
 354   if (opt_index == cl_options_count)
 355     goto done;
 356
 357   option = &cl_options[opt_index];
 358
 359   /* Reject negative form of switches that don't take negatives as
 360      unrecognized.  */
 361   if (!value && (option->flags & CL_REJECT_NEGATIVE))
 362     goto done;
 363
 364   /* We've recognized this switch.  */
 365   result = 1;
 366
 367   /* Sort out any argument the switch takes.  */
 368   if (option->flags & CL_JOINED)
 369     {
 370       /* Have arg point to the original switch.  This is because
 371          some code, such as disable_builtin_function, expects its
 372          argument to be persistent until the program exits.  */
 373       arg = argv[0] + cl_options[opt_index].opt_len + 1;
 374       if (!value)
 375         arg += strlen ("no-");
 376
 377       if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
 378         {
 379           if (option->flags & CL_SEPARATE)
 380             {
 381               arg = argv[1];
 382               result = 2;
 383             }
 384           else
 385             /* Missing argument.  */
 386             arg = NULL;
 387         }
 388     }
 389   else if (option->flags & CL_SEPARATE)
 390     {
 391       arg = argv[1];
 392       result = 2;
 393     }
 394
 395   /* Now we've swallowed any potential argument, complain if this
 396      is a switch for a different front end.  */
 397   if (!(option->flags & (lang_mask | CL_COMMON)))
 398     {
 399       complain_wrong_lang (argv[0], option, lang_mask);
 400       goto done;
 401     }
 402
 403   if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
 404     {
 405       if (!(*lang_hooks.missing_argument) (opt, opt_index))
 406         error ("missing argument to \"%s\"", opt);
 407       goto done;
 408     }
 409
 410   /* If the switch takes an integer, convert it.  */
 411   if (arg && (option->flags & CL_UINTEGER))
 412     {
 413       value = integral_argument (arg);
 414       if (value == -1)
 415         {
 416           error ("argument to \"%s\" should be a non-negative integer",
 417                  option->opt_text);
 418           goto done;
 419         }
 420     }
 421
 422   if (option->flags & lang_mask)
 423     if ((*lang_hooks.handle_option) (opt_index, arg, value) == 0)
 424       result = 0;
 425
 426   if (result && (option->flags & CL_COMMON))
 427     if (common_handle_option (opt_index, arg, value) == 0)
 428       result = 0;
 429
 430  done:
 431   if (dup)
 432     free (dup);
 433   return result;
 434 }
 435
 436 /* Decode and handle the vector of command line options.  LANG_MASK
 437    contains has a single bit set representing the current
 438    language.  */
 439 static void
 440 handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
 441 {
 442   unsigned int n, i;
 443
 444   for (i = 1; i < argc; i += n)
 445     {
 446       const char *opt = argv[i];
 447
 448       /* Interpret "-" or a non-switch as a file name.  */
 449       if (opt[0] != '-' || opt[1] == '\0')
 450         {
 451           main_input_filename = opt;
 452           add_input_filename (opt);
 453           n = 1;
 454           continue;
 455         }
 456
 457       n = handle_option (argv + i, lang_mask);
 458
 459       if (!n)
 460         {
 461           n = 1;
 462           error ("unrecognized command line option \"%s\"", opt);
 463         }
 464     }
 465 }
 466
 467 /* Handle FILENAME from the command line.  */
 468 void
 469 add_input_filename (const char *filename)
 470 {
 471   num_in_fnames++;
 472   in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0]));
 473   in_fnames[num_in_fnames - 1] = filename;
 474 }
 475
 476 /* Parse command line options and set default flag values.  Do minimal
 477    options processing.  */
 478 void
 479 decode_options (unsigned int argc, const char **argv)
 480 {
 481   unsigned int i, lang_mask;
 482
 483   /* Perform language-specific options initialization.  */
 484   lang_mask = (*lang_hooks.init_options) (argc, argv);
 485
 486   lang_hooks.initialize_diagnostics (global_dc);
 487
 488   /* Scan to see what optimization level has been specified.  That will
 489      determine the default value of many flags.  */
 490   for (i = 1; i < argc; i++)
 491     {
 492       if (!strcmp (argv[i], "-O"))
 493         {
 494           optimize = 1;
 495           optimize_size = 0;
 496         }
 497       else if (argv[i][0] == '-' && argv[i][1] == 'O')
 498         {
 499           /* Handle -Os, -O2, -O3, -O69, ...  */
 500           const char *p = &argv[i][2];
 501
 502           if ((p[0] == 's') && (p[1] == 0))
 503             {
 504               optimize_size = 1;
 505
 506               /* Optimizing for size forces optimize to be 2.  */
 507               optimize = 2;
 508             }
 509           else
 510             {
 511               const int optimize_val = read_integral_parameter (p, p - 2, -1);
 512               if (optimize_val != -1)
 513                 {
 514                   optimize = optimize_val;
 515                   optimize_size = 0;
 516                 }
 517             }
 518         }
 519     }
 520
 521   if (!optimize)
 522     {
 523       flag_merge_constants = 0;
 524     }
 525
 526   if (optimize >= 1)
 527     {
 528       flag_defer_pop = 1;
 529       flag_thread_jumps = 1;
 530 #ifdef DELAY_SLOTS
 531       flag_delayed_branch = 1;
 532 #endif
 533 #ifdef CAN_DEBUG_WITHOUT_FP
 534       flag_omit_frame_pointer = 1;
 535 #endif
 536       flag_guess_branch_prob = 1;
 537       flag_cprop_registers = 1;
 538       flag_loop_optimize = 1;
 539       flag_crossjumping = 1;
 540       flag_if_conversion = 1;
 541       flag_if_conversion2 = 1;
 542     }
 543
 544   if (optimize >= 2)
 545     {
 546       flag_optimize_sibling_calls = 1;
 547       flag_cse_follow_jumps = 1;
 548       flag_cse_skip_blocks = 1;
 549       flag_gcse = 1;
 550       flag_expensive_optimizations = 1;
 551       flag_strength_reduce = 1;
 552       flag_rerun_cse_after_loop = 1;
 553       flag_rerun_loop_opt = 1;
 554       flag_caller_saves = 1;
 555       flag_force_mem = 1;
 556       flag_peephole2 = 1;
 557 #ifdef INSN_SCHEDULING
 558       flag_schedule_insns = 1;
 559       flag_schedule_insns_after_reload = 1;
 560 #endif
 561       flag_regmove = 1;
 562       flag_strict_aliasing = 1;
 563       flag_delete_null_pointer_checks = 1;
 564       flag_reorder_blocks = 1;
 565       flag_reorder_functions = 1;
 566       flag_unit_at_a_time = 1;
 567     }
 568
 569   if (optimize >= 3)
 570     {
 571       flag_inline_functions = 1;
 572       flag_rename_registers = 1;
 573       flag_unswitch_loops = 1;
 574       flag_web = 1;
 575     }
 576
 577   if (optimize < 2 || optimize_size)
 578     {
 579       align_loops = 1;
 580       align_jumps = 1;
 581       align_labels = 1;
 582       align_functions = 1;
 583
 584       /* Don't reorder blocks when optimizing for size because extra
 585          jump insns may be created; also barrier may create extra padding.
 586
 587          More correctly we should have a block reordering mode that tried
 588          to minimize the combined size of all the jumps.  This would more
 589          or less automatically remove extra jumps, but would also try to
 590          use more short jumps instead of long jumps.  */
 591       flag_reorder_blocks = 0;
 592     }
 593
 594   /* Initialize whether `char' is signed.  */
 595   flag_signed_char = DEFAULT_SIGNED_CHAR;
 596 #ifdef DEFAULT_SHORT_ENUMS
 597   /* Initialize how much space enums occupy, by default.  */
 598   flag_short_enums = DEFAULT_SHORT_ENUMS;
 599 #endif
 600
 601   /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
 602      modify it.  */
 603   target_flags = 0;
 604   set_target_switch ("");
 605
 606   /* Unwind tables are always present in an ABI-conformant IA-64
 607      object file, so the default should be ON.  */
 608 #ifdef IA64_UNWIND_INFO
 609   flag_unwind_tables = IA64_UNWIND_INFO;
 610 #endif
 611
 612 #ifdef OPTIMIZATION_OPTIONS
 613   /* Allow default optimizations to be specified on a per-machine basis.  */
 614   OPTIMIZATION_OPTIONS (optimize, optimize_size);
 615 #endif
 616
 617   handle_options (argc, argv, lang_mask);
 618
 619   if (flag_pie)
 620     flag_pic = flag_pie;
 621   if (flag_pic && !flag_pie)
 622     flag_shlib = 1;
 623
 624   if (flag_no_inline == 2)
 625     flag_no_inline = 0;
 626   else
 627     flag_really_no_inline = flag_no_inline;
 628
 629   /* Set flag_no_inline before the post_options () hook.  The C front
 630      ends use it to determine tree inlining defaults.  FIXME: such
 631      code should be lang-independent when all front ends use tree
 632      inlining, in which case it, and this condition, should be moved
 633      to the top of process_options() instead.  */
 634   if (optimize == 0)
 635     {
 636       /* Inlining does not work if not optimizing,
 637          so force it not to be done.  */
 638       flag_no_inline = 1;
 639       warn_inline = 0;
 640
 641       /* The c_decode_option function and decode_option hook set
 642          this to `2' if -Wall is used, so we can avoid giving out
 643          lots of errors for people who don't realize what -Wall does.  */
 644       if (warn_uninitialized == 1)
 645         warning ("-Wuninitialized is not supported without -O");
 646     }
 647
 648   if (flag_really_no_inline == 2)
 649     flag_really_no_inline = flag_no_inline;
 650 }
 651
 652 /* Handle target- and language-independent options.  Return zero to
 653    generate an "unknown option" message.  */
 654 static int
 655 common_handle_option (size_t scode, const char *arg,
 656                       int value ATTRIBUTE_UNUSED)
 657 {
 658   enum opt_code code = (enum opt_code) scode;
 659
 660   switch (code)
 661     {
 662     default:
 663       abort ();
 664
 665     case OPT__help:
 666       print_help ();
 667       exit_after_options = true;
 668       break;
 669
 670     case OPT__param:
 671       handle_param (arg);
 672       break;
 673
 674     case OPT__target_help:
 675       display_target_options ();
 676       exit_after_options = true;
 677       break;
 678
 679     case OPT__version:
 680       print_version (stderr, "");
 681       exit_after_options = true;
 682       break;
 683
 684     case OPT_G:
 685       g_switch_value = value;
 686       g_switch_set = true;
 687       break;
 688
 689     case OPT_O:
 690     case OPT_Os:
 691       /* Currently handled in a prescan.  */
 692       break;
 693
 694     case OPT_W:
 695       /* For backward compatibility, -W is the same as -Wextra.  */
 696       set_Wextra (value);
 697       break;
 698
 699     case OPT_Waggregate_return:
 700       warn_aggregate_return = value;
 701       break;
 702
 703     case OPT_Wcast_align:
 704       warn_cast_align = value;
 705       break;
 706
 707     case OPT_Wdeprecated_declarations:
 708       warn_deprecated_decl = value;
 709       break;
 710
 711     case OPT_Wdisabled_optimization:
 712       warn_disabled_optimization = value;
 713       break;
 714
 715     case OPT_Werror:
 716       warnings_are_errors = value;
 717       break;
 718
 719     case OPT_Wextra:
 720       set_Wextra (value);
 721       break;
 722
 723     case OPT_Winline:
 724       warn_inline = value;
 725       break;
 726
 727     case OPT_Wlarger_than_:
 728       larger_than_size = value;
 729       warn_larger_than = value != -1;
 730       break;
 731
 732     case OPT_Wmissing_noreturn:
 733       warn_missing_noreturn = value;
 734       break;
 735
 736     case OPT_Wpacked:
 737       warn_packed = value;
 738       break;
 739
 740     case OPT_Wpadded:
 741       warn_padded = value;
 742       break;
 743
 744     case OPT_Wshadow:
 745       warn_shadow = value;
 746       break;
 747
 748     case OPT_Wstrict_aliasing:
 749       warn_strict_aliasing = value;
 750       break;
 751
 752     case OPT_Wswitch:
 753       warn_switch = value;
 754       break;
 755
 756     case OPT_Wswitch_default:
 757       warn_switch_default = value;
 758       break;
 759
 760     case OPT_Wswitch_enum:
 761       warn_switch_enum = value;
 762       break;
 763
 764     case OPT_Wsystem_headers:
 765       warn_system_headers = value;
 766       break;
 767
 768     case OPT_Wuninitialized:
 769       warn_uninitialized = value;
 770       break;
 771
 772     case OPT_Wunreachable_code:
 773       warn_notreached = value;
 774       break;
 775
 776     case OPT_Wunused:
 777       set_Wunused (value);
 778       break;
 779
 780     case OPT_Wunused_function:
 781       warn_unused_function = value;
 782       break;
 783
 784     case OPT_Wunused_label:
 785       warn_unused_label = value;
 786       break;
 787
 788     case OPT_Wunused_parameter:
 789       warn_unused_parameter = value;
 790       break;
 791
 792     case OPT_Wunused_value:
 793       warn_unused_value = value;
 794       break;
 795
 796     case OPT_Wunused_variable:
 797       warn_unused_variable = value;
 798       break;
 799
 800     case OPT_aux_info:
 801     case OPT_aux_info_:
 802       aux_info_file_name = arg;
 803       flag_gen_aux_info = 1;
 804       break;
 805
 806     case OPT_auxbase:
 807       aux_base_name = arg;
 808       break;
 809
 810     case OPT_auxbase_strip:
 811       {
 812         char *tmp = xstrdup (arg);
 813         strip_off_ending (tmp, strlen (tmp));
 814         if (tmp[0])
 815           aux_base_name = tmp;
 816       }
 817       break;
 818
 819     case OPT_d:
 820       decode_d_option (arg);
 821       break;
 822
 823     case OPT_dumpbase:
 824       dump_base_name = arg;
 825       break;
 826
 827     case OPT_fPIC:
 828       flag_pic = value + value;
 829       break;
 830
 831     case OPT_fPIE:
 832       flag_pie = value + value;
 833       break;
 834
 835     case OPT_falign_functions:
 836       align_functions = !value;
 837       break;
 838
 839     case OPT_falign_functions_:
 840       align_functions = value;
 841       break;
 842
 843     case OPT_falign_jumps:
 844       align_jumps = !value;
 845       break;
 846
 847     case OPT_falign_jumps_:
 848       align_jumps = value;
 849       break;
 850
 851     case OPT_falign_labels:
 852       align_labels = !value;
 853       break;
 854
 855     case OPT_falign_labels_:
 856       align_labels = value;
 857       break;
 858
 859     case OPT_falign_loops:
 860       align_loops = !value;
 861       break;
 862
 863     case OPT_falign_loops_:
 864       align_loops = value;
 865       break;
 866
 867     case OPT_fargument_alias:
 868       flag_argument_noalias = !value;
 869       break;
 870
 871     case OPT_fargument_noalias:
 872       flag_argument_noalias = value;
 873       break;
 874
 875     case OPT_fargument_noalias_global:
 876       flag_argument_noalias = value + value;
 877       break;
 878
 879     case OPT_fasynchronous_unwind_tables:
 880       flag_asynchronous_unwind_tables = value;
 881       break;
 882
 883     case OPT_fbounds_check:
 884       flag_bounds_check = value;
 885       break;
 886
 887     case OPT_fbranch_count_reg:
 888       flag_branch_on_count_reg = value;
 889       break;
 890
 891     case OPT_fbranch_probabilities:
 892       flag_branch_probabilities_set = true;
 893       flag_branch_probabilities = value;
 894       break;
 895
 896     case OPT_fbranch_target_load_optimize:
 897       flag_branch_target_load_optimize = value;
 898       break;
 899
 900     case OPT_fbranch_target_load_optimize2:
 901       flag_branch_target_load_optimize2 = value;
 902       break;
 903
 904     case OPT_fcall_used_:
 905       fix_register (arg, 0, 1);
 906       break;
 907
 908     case OPT_fcall_saved_:
 909       fix_register (arg, 0, 0);
 910       break;
 911
 912     case OPT_fcaller_saves:
 913       flag_caller_saves = value;
 914       break;
 915
 916     case OPT_fcommon:
 917       flag_no_common = !value;
 918       break;
 919
 920     case OPT_fcprop_registers:
 921       flag_cprop_registers = value;
 922       break;
 923
 924     case OPT_fcrossjumping:
 925       flag_crossjumping = value;
 926       break;
 927
 928     case OPT_fcse_follow_jumps:
 929       flag_cse_follow_jumps = value;
 930       break;
 931
 932     case OPT_fcse_skip_blocks:
 933       flag_cse_skip_blocks = value;
 934       break;
 935
 936     case OPT_fdata_sections:
 937       flag_data_sections = value;
 938       break;
 939
 940     case OPT_fdefer_pop:
 941       flag_defer_pop = value;
 942       break;
 943
 944     case OPT_fdelayed_branch:
 945       flag_delayed_branch = value;
 946       break;
 947
 948     case OPT_fdelete_null_pointer_checks:
 949       flag_delete_null_pointer_checks = value;
 950       break;
 951
 952     case OPT_fdiagnostics_show_location_:
 953       if (!strcmp (arg, "once"))
 954         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 955       else if (!strcmp (arg, "every-line"))
 956         diagnostic_prefixing_rule (global_dc)
 957           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
 958       else
 959         return 0;
 960       break;
 961
 962     case OPT_fdump_unnumbered:
 963       flag_dump_unnumbered = value;
 964       break;
 965
 966     case OPT_feliminate_dwarf2_dups:
 967       flag_eliminate_dwarf2_dups = value;
 968       break;
 969
 970     case OPT_feliminate_unused_debug_types:
 971       flag_eliminate_unused_debug_types = value;
 972       break;
 973
 974     case OPT_feliminate_unused_debug_symbols:
 975       flag_debug_only_used_symbols = value;
 976       break;
 977
 978     case OPT_fexceptions:
 979       flag_exceptions = value;
 980       break;
 981
 982     case OPT_fexpensive_optimizations:
 983       flag_expensive_optimizations = value;
 984       break;
 985
 986     case OPT_ffast_math:
 987       set_fast_math_flags (value);
 988       break;
 989
 990     case OPT_ffinite_math_only:
 991       flag_finite_math_only = value;
 992       break;
 993
 994     case OPT_ffixed_:
 995       fix_register (arg, 1, 1);
 996       break;
 997
 998     case OPT_ffunction_cse:
 999       flag_no_function_cse = !value;
1000       break;
1001
1002     case OPT_ffloat_store:
1003       flag_float_store = value;
1004       break;
1005
1006     case OPT_fforce_addr:
1007       flag_force_addr = value;
1008       break;
1009
1010     case OPT_fforce_mem:
1011       flag_force_mem = value;
1012       break;
1013
1014     case OPT_ffunction_sections:
1015       flag_function_sections = value;
1016       break;
1017
1018     case OPT_fgcse:
1019       flag_gcse = value;
1020       break;
1021
1022     case OPT_fgcse_lm:
1023       flag_gcse_lm = value;
1024       break;
1025
1026     case OPT_fgcse_sm:
1027       flag_gcse_sm = value;
1028       break;
1029
1030     case OPT_fgcse_las:
1031       flag_gcse_las = value;
1032       break;
1033
1034     case OPT_fguess_branch_probability:
1035       flag_guess_branch_prob = value;
1036       break;
1037
1038     case OPT_fident:
1039       flag_no_ident = !value;
1040       break;
1041
1042     case OPT_fif_conversion:
1043       flag_if_conversion = value;
1044       break;
1045
1046     case OPT_fif_conversion2:
1047       flag_if_conversion2 = value;
1048       break;
1049
1050     case OPT_finhibit_size_directive:
1051       flag_inhibit_size_directive = value;
1052       break;
1053
1054     case OPT_finline:
1055       flag_no_inline = !value;
1056       break;
1057
1058     case OPT_finline_functions:
1059       flag_inline_functions = value;
1060       break;
1061
1062     case OPT_finline_limit_:
1063     case OPT_finline_limit_eq:
1064       set_param_value ("max-inline-insns-single", value / 2);
1065       set_param_value ("max-inline-insns-auto", value / 2);
1066       set_param_value ("max-inline-insns-rtl", value);
1067       break;
1068
1069     case OPT_finstrument_functions:
1070       flag_instrument_function_entry_exit = value;
1071       break;
1072
1073     case OPT_fkeep_inline_functions:
1074       flag_keep_inline_functions =value;
1075       break;
1076
1077     case OPT_fkeep_static_consts:
1078       flag_keep_static_consts = value;
1079       break;
1080
1081     case OPT_fleading_underscore:
1082       flag_leading_underscore = value;
1083       break;
1084
1085     case OPT_floop_optimize:
1086       flag_loop_optimize = value;
1087       break;
1088
1089     case OPT_fmath_errno:
1090       flag_errno_math = value;
1091       break;
1092
1093     case OPT_fmem_report:
1094       mem_report = value;
1095       break;
1096
1097     case OPT_fmerge_all_constants:
1098       flag_merge_constants = value + value;
1099       break;
1100
1101     case OPT_fmerge_constants:
1102       flag_merge_constants = value;
1103       break;
1104
1105     case OPT_fmessage_length_:
1106       pp_set_line_maximum_length (global_dc->printer, value);
1107       break;
1108
1109     case OPT_fmove_all_movables:
1110       flag_move_all_movables = value;
1111       break;
1112
1113     case OPT_fnew_ra:
1114       flag_new_regalloc = value;
1115       break;
1116
1117     case OPT_fnon_call_exceptions:
1118       flag_non_call_exceptions = value;
1119       break;
1120
1121     case OPT_fold_unroll_all_loops:
1122       flag_old_unroll_all_loops = value;
1123       break;
1124
1125     case OPT_fold_unroll_loops:
1126       flag_old_unroll_loops = value;
1127       break;
1128
1129     case OPT_fomit_frame_pointer:
1130       flag_omit_frame_pointer = value;
1131       break;
1132
1133     case OPT_foptimize_register_move:
1134       flag_regmove = value;
1135       break;
1136
1137     case OPT_foptimize_sibling_calls:
1138       flag_optimize_sibling_calls = value;
1139       break;
1140
1141     case OPT_fpack_struct:
1142       flag_pack_struct = value;
1143       break;
1144
1145     case OPT_fpeel_loops:
1146       flag_peel_loops_set = true;
1147       flag_peel_loops = value;
1148       break;
1149
1150     case OPT_fpcc_struct_return:
1151       flag_pcc_struct_return = value;
1152       break;
1153
1154     case OPT_fpeephole:
1155       flag_no_peephole = !value;
1156       break;
1157
1158     case OPT_fpeephole2:
1159       flag_peephole2 = value;
1160       break;
1161
1162     case OPT_fpic:
1163       flag_pic = value;
1164       break;
1165
1166     case OPT_fpie:
1167       flag_pie = value;
1168       break;
1169
1170     case OPT_fprefetch_loop_arrays:
1171       flag_prefetch_loop_arrays = value;
1172       break;
1173
1174     case OPT_fprofile:
1175       profile_flag = value;
1176       break;
1177
1178     case OPT_fprofile_arcs:
1179       profile_arc_flag_set = true;
1180       profile_arc_flag = value;
1181       break;
1182
1183     case OPT_fprofile_use:
1184       if (!flag_branch_probabilities_set)
1185         flag_branch_probabilities = value;
1186       if (!flag_profile_values_set)
1187         flag_profile_values = value;
1188       if (!flag_unroll_loops_set)
1189         flag_unroll_loops = value;
1190       if (!flag_peel_loops_set)
1191         flag_peel_loops = value;
1192       if (!flag_tracer_set)
1193         flag_tracer = value;
1194       if (!flag_value_profile_transformations_set)
1195         flag_value_profile_transformations = value;
1196       break;
1197
1198     case OPT_fprofile_generate:
1199       if (!profile_arc_flag_set)
1200         profile_arc_flag = value;
1201       if (!flag_profile_values_set)
1202         flag_profile_values = value;
1203       if (!flag_value_profile_transformations_set)
1204         flag_value_profile_transformations = value;
1205       break;
1206
1207     case OPT_fprofile_values:
1208       flag_profile_values_set = true;
1209       flag_profile_values = value;
1210       break;
1211
1212     case OPT_fvpt:
1213       flag_value_profile_transformations_set = value;
1214       flag_value_profile_transformations = value;
1215       break;
1216
1217     case OPT_frandom_seed:
1218       /* The real switch is -fno-random-seed.  */
1219       if (value)
1220         return 0;
1221       flag_random_seed = NULL;
1222       break;
1223
1224     case OPT_frandom_seed_:
1225       flag_random_seed = arg;
1226       break;
1227
1228     case OPT_freduce_all_givs:
1229       flag_reduce_all_givs = value;
1230       break;
1231
1232     case OPT_freg_struct_return:
1233       flag_pcc_struct_return = !value;
1234       break;
1235
1236     case OPT_fregmove:
1237       flag_regmove = value;
1238       break;
1239
1240     case OPT_frename_registers:
1241       flag_rename_registers = value;
1242       break;
1243
1244     case OPT_freorder_blocks:
1245       flag_reorder_blocks = value;
1246       break;
1247
1248     case OPT_freorder_functions:
1249       flag_reorder_functions = value;
1250       break;
1251
1252     case OPT_frerun_cse_after_loop:
1253       flag_rerun_cse_after_loop = value;
1254       break;
1255
1256     case OPT_frerun_loop_opt:
1257       flag_rerun_loop_opt = value;
1258       break;
1259
1260     case OPT_frounding_math:
1261       flag_rounding_math = value;
1262       break;
1263
1264     case OPT_fsched_interblock:
1265       flag_schedule_interblock = value;
1266       break;
1267
1268     case OPT_fsched_spec:
1269       flag_schedule_speculative = value;
1270       break;
1271
1272     case OPT_fsched_spec_load:
1273       flag_schedule_speculative_load = value;
1274       break;
1275
1276     case OPT_fsched_spec_load_dangerous:
1277       flag_schedule_speculative_load_dangerous = value;
1278       break;
1279
1280     case OPT_fsched_verbose_:
1281 #ifdef INSN_SCHEDULING
1282       fix_sched_param ("verbose", arg);
1283       break;
1284 #else
1285       return 0;
1286 #endif
1287
1288     case OPT_fsched2_use_superblocks:
1289       flag_sched2_use_superblocks = value;
1290       break;
1291
1292     case OPT_fsched2_use_traces:
1293       flag_sched2_use_traces = value;
1294       break;
1295
1296     case OPT_fschedule_insns:
1297       flag_schedule_insns = value;
1298       break;
1299
1300     case OPT_fschedule_insns2:
1301       flag_schedule_insns_after_reload = value;
1302       break;
1303
1304     case OPT_fsched_stalled_insns:
1305       flag_sched_stalled_insns = value;
1306       break;
1307
1308     case OPT_fsched_stalled_insns_:
1309       flag_sched_stalled_insns = value;
1310       if (flag_sched_stalled_insns == 0)
1311         flag_sched_stalled_insns = -1;
1312       break;
1313
1314     case OPT_fsched_stalled_insns_dep:
1315       flag_sched_stalled_insns_dep = 1;
1316       break;
1317
1318     case OPT_fsched_stalled_insns_dep_:
1319       flag_sched_stalled_insns_dep = value;
1320       break;
1321
1322     case OPT_fshared_data:
1323       flag_shared_data = value;
1324       break;
1325
1326     case OPT_fsignaling_nans:
1327       flag_signaling_nans = value;
1328       break;
1329
1330     case OPT_fsingle_precision_constant:
1331       flag_single_precision_constant = value;
1332       break;
1333
1334     case OPT_fstack_check:
1335       flag_stack_check = value;
1336       break;
1337
1338     case OPT_fstack_limit:
1339       /* The real switch is -fno-stack-limit.  */
1340       if (value)
1341         return 0;
1342       stack_limit_rtx = NULL_RTX;
1343       break;
1344
1345     case OPT_fstack_limit_register_:
1346       {
1347         int reg = decode_reg_name (arg);
1348         if (reg < 0)
1349           error ("unrecognized register name \"%s\"", arg);
1350         else
1351           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1352       }
1353       break;
1354
1355     case OPT_fstack_limit_symbol_:
1356       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1357       break;
1358
1359     case OPT_fstrength_reduce:
1360       flag_strength_reduce = value;
1361       break;
1362
1363     case OPT_fstrict_aliasing:
1364       flag_strict_aliasing = value;
1365       break;
1366
1367     case OPT_fsyntax_only:
1368       flag_syntax_only = value;
1369       break;
1370
1371     case OPT_ftest_coverage:
1372       flag_test_coverage = value;
1373       break;
1374
1375     case OPT_fthread_jumps:
1376       flag_thread_jumps = value;
1377       break;
1378
1379     case OPT_ftime_report:
1380       time_report = value;
1381       break;
1382
1383     case OPT_ftls_model_:
1384       if (!strcmp (arg, "global-dynamic"))
1385         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1386       else if (!strcmp (arg, "local-dynamic"))
1387         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1388       else if (!strcmp (arg, "initial-exec"))
1389         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1390       else if (!strcmp (arg, "local-exec"))
1391         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1392       else
1393         warning ("unknown tls-model \"%s\"", arg);
1394       break;
1395
1396     case OPT_ftracer:
1397       flag_tracer_set = true;
1398       flag_tracer = value;
1399       break;
1400
1401     case OPT_ftrapping_math:
1402       flag_trapping_math = value;
1403       break;
1404
1405     case OPT_ftrapv:
1406       flag_trapv = value;
1407       break;
1408
1409     case OPT_funit_at_a_time:
1410       flag_unit_at_a_time = value;
1411       break;
1412
1413     case OPT_funroll_all_loops:
1414       flag_unroll_all_loops = value;
1415       break;
1416
1417     case OPT_funroll_loops:
1418       flag_unroll_loops_set = true;
1419       flag_unroll_loops = value;
1420       break;
1421
1422     case OPT_funsafe_math_optimizations:
1423       flag_unsafe_math_optimizations = value;
1424       break;
1425
1426     case OPT_funswitch_loops:
1427       flag_unswitch_loops = value;
1428       break;
1429
1430     case OPT_funwind_tables:
1431       flag_unwind_tables = value;
1432       break;
1433
1434     case OPT_fverbose_asm:
1435       flag_verbose_asm = value;
1436       break;
1437
1438     case OPT_fweb:
1439       flag_web = value;
1440       break;
1441
1442     case OPT_fwrapv:
1443       flag_wrapv = value;
1444       break;
1445
1446     case OPT_fwritable_strings:
1447       flag_writable_strings = value;
1448       break;
1449
1450     case OPT_fzero_initialized_in_bss:
1451       flag_zero_initialized_in_bss = value;
1452       break;
1453
1454     case OPT_g:
1455       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
1456       break;
1457
1458     case OPT_gcoff:
1459       set_debug_level (SDB_DEBUG, false, arg);
1460       break;
1461
1462     case OPT_gdwarf:
1463       if (*arg)
1464         {
1465           error ("use -gdwarf -gN for DWARF v1 level N, "
1466                  "and -gdwarf-2 for DWARF v2" );
1467           break;
1468         }
1469
1470       /* Fall through.  */
1471     case OPT_gdwarf_:
1472       set_debug_level (DWARF_DEBUG, code == OPT_gdwarf_, arg);
1473       break;
1474
1475     case OPT_gdwarf_2:
1476       set_debug_level (DWARF2_DEBUG, false, arg);
1477       break;
1478
1479     case OPT_ggdb:
1480       set_debug_level (NO_DEBUG, 2, arg);
1481       break;
1482
1483     case OPT_gstabs:
1484     case OPT_gstabs_:
1485       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
1486       break;
1487
1488     case OPT_gvms:
1489       set_debug_level (VMS_DEBUG, false, arg);
1490       break;
1491
1492     case OPT_gxcoff:
1493     case OPT_gxcoff_:
1494       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
1495       break;
1496
1497     case OPT_m:
1498       set_target_switch (arg);
1499       break;
1500
1501     case OPT_o:
1502       asm_file_name = arg;
1503       break;
1504
1505     case OPT_p:
1506       profile_flag = 1;
1507       break;
1508
1509     case OPT_pedantic:
1510       pedantic = 1;
1511       break;
1512
1513     case OPT_pedantic_errors:
1514       flag_pedantic_errors = pedantic = 1;
1515       break;
1516
1517     case OPT_quiet:
1518       quiet_flag = 1;
1519       break;
1520
1521     case OPT_version:
1522       version_flag = 1;
1523       break;
1524
1525     case OPT_w:
1526       inhibit_warnings = true;
1527       break;
1528     }
1529
1530   return 1;
1531 }
1532
1533 /* Handle --param NAME=VALUE.  */
1534 static void
1535 handle_param (const char *carg)
1536 {
1537   char *equal, *arg;
1538   int value;
1539
1540   arg = xstrdup (carg);
1541   equal = strchr (arg, '=');
1542   if (!equal)
1543     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1544   else
1545     {
1546       value = integral_argument (equal + 1);
1547       if (value == -1)
1548         error ("invalid --param value `%s'", equal + 1);
1549       else
1550         {
1551           *equal = '\0';
1552           set_param_value (arg, value);
1553         }
1554     }
1555
1556   free (arg);
1557 }
1558
1559 /* Handle -W and -Wextra.  */
1560 static void
1561 set_Wextra (int setting)
1562 {
1563   extra_warnings = setting;
1564   warn_unused_value = setting;
1565   warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1566
1567   /* We save the value of warn_uninitialized, since if they put
1568      -Wuninitialized on the command line, we need to generate a
1569      warning about not using it without also specifying -O.  */
1570   if (setting == 0)
1571     warn_uninitialized = 0;
1572   else if (warn_uninitialized != 1)
1573     warn_uninitialized = 2;
1574 }
1575
1576 /* Initialize unused warning flags.  */
1577 void
1578 set_Wunused (int setting)
1579 {
1580   warn_unused_function = setting;
1581   warn_unused_label = setting;
1582   /* Unused function parameter warnings are reported when either
1583      ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1584      Thus, if -Wextra has already been seen, set warn_unused_parameter;
1585      otherwise set maybe_warn_extra_parameter, which will be picked up
1586      by set_Wextra.  */
1587   maybe_warn_unused_parameter = setting;
1588   warn_unused_parameter = (setting && extra_warnings);
1589   warn_unused_variable = setting;
1590   warn_unused_value = setting;
1591 }
1592
1593 /* The following routines are useful in setting all the flags that
1594    -ffast-math and -fno-fast-math imply.  */
1595 void
1596 set_fast_math_flags (int set)
1597 {
1598   flag_trapping_math = !set;
1599   flag_unsafe_math_optimizations = set;
1600   flag_finite_math_only = set;
1601   flag_errno_math = !set;
1602   if (set)
1603     {
1604       flag_signaling_nans = 0;
1605       flag_rounding_math = 0;
1606     }
1607 }
1608
1609 /* Return true iff flags are set as if -ffast-math.  */
1610 bool
1611 fast_math_flags_set_p (void)
1612 {
1613   return (!flag_trapping_math
1614           && flag_unsafe_math_optimizations
1615           && flag_finite_math_only
1616           && !flag_errno_math);
1617 }
1618
1619 /* Handle a debug output -g switch.  EXTENDED is true or false to support
1620    extended output (2 is special and means "-ggdb" was given).  */
1621 static void
1622 set_debug_level (enum debug_info_type type, int extended, const char *arg)
1623 {
1624   static bool type_explicit;
1625
1626   use_gnu_debug_info_extensions = extended;
1627
1628   if (type == NO_DEBUG)
1629     {
1630       if (write_symbols == NO_DEBUG)
1631         {
1632           write_symbols = PREFERRED_DEBUGGING_TYPE;
1633
1634           if (extended == 2)
1635             {
1636 #ifdef DWARF2_DEBUGGING_INFO
1637               write_symbols = DWARF2_DEBUG;
1638 #elif defined DBX_DEBUGGING_INFO
1639               write_symbols = DBX_DEBUG;
1640 #endif
1641             }
1642
1643           if (write_symbols == NO_DEBUG)
1644             warning ("target system does not support debug output");
1645         }
1646     }
1647   else
1648     {
1649       /* Does it conflict with an already selected type?  */
1650       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1651         error ("debug format \"%s\" conflicts with prior selection",
1652                debug_type_names[type]);
1653       write_symbols = type;
1654       type_explicit = true;
1655     }
1656
1657   /* A debug flag without a level defaults to level 2.  */
1658   if (*arg == '\0')
1659     {
1660       if (!debug_info_level)
1661         debug_info_level = 2;
1662     }
1663   else
1664     {
1665       debug_info_level = integral_argument (arg);
1666       if (debug_info_level == (unsigned int) -1)
1667         error ("unrecognised debug output level \"%s\"", arg);
1668       else if (debug_info_level > 3)
1669         error ("debug output level %s is too high", arg);
1670     }
1671 }
1672
1673 /* Output --help text.  */
1674 static void
1675 print_help (void)
1676 {
1677   size_t i;
1678   const char *p;
1679
1680   GET_ENVIRONMENT (p, "COLUMNS");
1681   if (p)
1682     {
1683       int value = atoi (p);
1684       if (value > 0)
1685         columns = value;
1686     }
1687
1688   puts (_("The following options are language-independent:\n"));
1689
1690   print_filtered_help (CL_COMMON);
1691   print_param_help ();
1692
1693   for (i = 0; lang_names[i]; i++)
1694     {
1695       printf (_("The %s front end recognizes the following options:\n\n"),
1696               lang_names[i]);
1697       print_filtered_help (1U << i);
1698     }
1699
1700   display_target_options ();
1701 }
1702
1703 /* Print the help for --param.  */
1704 static void
1705 print_param_help (void)
1706 {
1707   size_t i;
1708
1709   puts (_("The --param option recognizes the following as parameters:\n"));
1710
1711   for (i = 0; i < LAST_PARAM; i++)
1712     {
1713       const char *help = compiler_params[i].help;
1714       const char *param = compiler_params[i].option;
1715
1716       if (help == NULL || *help == '\0')
1717         help = undocumented_msg;
1718
1719       /* Get the translation.  */
1720       help = _(help);
1721
1722       wrap_help (help, param, strlen (param));
1723     }
1724
1725   putchar ('\n');
1726 }
1727
1728 /* Print help for a specific front-end, etc.  */
1729 static void
1730 print_filtered_help (unsigned int flag)
1731 {
1732   unsigned int i, len, filter, indent = 0;
1733   bool duplicates = false;
1734   const char *help, *opt, *tab;
1735   static char *printed;
1736
1737   if (flag == CL_COMMON)
1738     {
1739       filter = flag;
1740       if (!printed)
1741         printed = xmalloc (cl_options_count);
1742       memset (printed, 0, cl_options_count);
1743     }
1744   else
1745     {
1746       /* Don't print COMMON options twice.  */
1747       filter = flag | CL_COMMON;
1748
1749       for (i = 0; i < cl_options_count; i++)
1750         {
1751           if ((cl_options[i].flags & filter) != flag)
1752             continue;
1753
1754           /* Skip help for internal switches.  */
1755           if (cl_options[i].flags & CL_UNDOCUMENTED)
1756             continue;
1757
1758           /* Skip switches that have already been printed, mark them to be
1759              listed later.  */
1760           if (printed[i])
1761             {
1762               duplicates = true;
1763               indent = print_switch (cl_options[i].opt_text, indent);
1764             }
1765         }
1766
1767       if (duplicates)
1768         {
1769           putchar ('\n');
1770           putchar ('\n');
1771         }
1772     }
1773
1774   for (i = 0; i < cl_options_count; i++)
1775     {
1776       if ((cl_options[i].flags & filter) != flag)
1777         continue;
1778
1779       /* Skip help for internal switches.  */
1780       if (cl_options[i].flags & CL_UNDOCUMENTED)
1781         continue;
1782
1783       /* Skip switches that have already been printed.  */
1784       if (printed[i])
1785         continue;
1786
1787       printed[i] = true;
1788
1789       help = cl_options[i].help;
1790       if (!help)
1791         help = undocumented_msg;
1792
1793       /* Get the translation.  */
1794       help = _(help);
1795
1796       tab = strchr (help, '\t');
1797       if (tab)
1798         {
1799           len = tab - help;
1800           opt = help;
1801           help = tab + 1;
1802         }
1803       else
1804         {
1805           opt = cl_options[i].opt_text;
1806           len = strlen (opt);
1807         }
1808
1809       wrap_help (help, opt, len);
1810     }
1811
1812   putchar ('\n');
1813 }
1814
1815 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1816    word-wrapped HELP in a second column.  */
1817 static unsigned int
1818 print_switch (const char *text, unsigned int indent)
1819 {
1820   unsigned int len = strlen (text) + 1; /* trailing comma */
1821
1822   if (indent)
1823     {
1824       putchar (',');
1825       if (indent + len > columns)
1826         {
1827           putchar ('\n');
1828           putchar (' ');
1829           indent = 1;
1830         }
1831     }
1832   else
1833     putchar (' ');
1834
1835   putchar (' ');
1836   fputs (text, stdout);
1837
1838   return indent + len + 1;
1839 }
1840
1841 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1842    word-wrapped HELP in a second column.  */
1843 static void
1844 wrap_help (const char *help, const char *item, unsigned int item_width)
1845 {
1846   unsigned int col_width = 27;
1847   unsigned int remaining, room, len;
1848
1849   remaining = strlen (help);
1850
1851   do
1852     {
1853       room = columns - 3 - MAX (col_width, item_width);
1854       if (room > columns)
1855         room = 0;
1856       len = remaining;
1857
1858       if (room < len)
1859         {
1860           unsigned int i;
1861
1862           for (i = 0; help[i]; i++)
1863             {
1864               if (i >= room && len != remaining)
1865                 break;
1866               if (help[i] == ' ')
1867                 len = i;
1868               else if ((help[i] == '-' || help[i] == '/')
1869                        && help[i + 1] != ' '
1870                        && i > 0 && ISALPHA (help[i - 1]))
1871                 len = i + 1;
1872             }
1873         }
1874
1875       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1876       item_width = 0;
1877       while (help[len] == ' ')
1878         len++;
1879       help += len;
1880       remaining -= len;
1881     }
1882   while (remaining);
1883 }