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