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 int 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       flag_gcse_after_reload = 1;
 578     }
 579
 580   if (optimize < 2 || optimize_size)
 581     {
 582       align_loops = 1;
 583       align_jumps = 1;
 584       align_labels = 1;
 585       align_functions = 1;
 586
 587       /* Don't reorder blocks when optimizing for size because extra
 588          jump insns may be created; also barrier may create extra padding.
 589
 590          More correctly we should have a block reordering mode that tried
 591          to minimize the combined size of all the jumps.  This would more
 592          or less automatically remove extra jumps, but would also try to
 593          use more short jumps instead of long jumps.  */
 594       flag_reorder_blocks = 0;
 595     }
 596
 597   if (optimize_size)
 598     {
 599       /* Inlining of very small functions usually reduces total size.  */
 600       set_param_value ("max-inline-insns-single", 5);
 601       set_param_value ("max-inline-insns-auto", 5);
 602       set_param_value ("max-inline-insns-rtl", 10);
 603       flag_inline_functions = 1;
 604     }
 605
 606   /* Initialize whether `char' is signed.  */
 607   flag_signed_char = DEFAULT_SIGNED_CHAR;
 608   /* Initialize how much space enums occupy, by default.  */
 609   flag_short_enums = targetm.default_short_enums ();
 610
 611   /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
 612      modify it.  */
 613   target_flags = 0;
 614   set_target_switch ("");
 615
 616   /* Unwind tables are always present in an ABI-conformant IA-64
 617      object file, so the default should be ON.  */
 618 #ifdef IA64_UNWIND_INFO
 619   flag_unwind_tables = IA64_UNWIND_INFO;
 620 #endif
 621
 622 #ifdef OPTIMIZATION_OPTIONS
 623   /* Allow default optimizations to be specified on a per-machine basis.  */
 624   OPTIMIZATION_OPTIONS (optimize, optimize_size);
 625 #endif
 626
 627   handle_options (argc, argv, lang_mask);
 628
 629   if (flag_pie)
 630     flag_pic = flag_pie;
 631   if (flag_pic && !flag_pie)
 632     flag_shlib = 1;
 633
 634   if (flag_no_inline == 2)
 635     flag_no_inline = 0;
 636   else
 637     flag_really_no_inline = flag_no_inline;
 638
 639   /* Set flag_no_inline before the post_options () hook.  The C front
 640      ends use it to determine tree inlining defaults.  FIXME: such
 641      code should be lang-independent when all front ends use tree
 642      inlining, in which case it, and this condition, should be moved
 643      to the top of process_options() instead.  */
 644   if (optimize == 0)
 645     {
 646       /* Inlining does not work if not optimizing,
 647          so force it not to be done.  */
 648       flag_no_inline = 1;
 649       warn_inline = 0;
 650
 651       /* The c_decode_option function and decode_option hook set
 652          this to `2' if -Wall is used, so we can avoid giving out
 653          lots of errors for people who don't realize what -Wall does.  */
 654       if (warn_uninitialized == 1)
 655         warning ("-Wuninitialized is not supported without -O");
 656     }
 657
 658   if (flag_really_no_inline == 2)
 659     flag_really_no_inline = flag_no_inline;
 660 }
 661
 662 /* Handle target- and language-independent options.  Return zero to
 663    generate an "unknown option" message.  */
 664 static int
 665 common_handle_option (size_t scode, const char *arg,
 666                       int value ATTRIBUTE_UNUSED)
 667 {
 668   enum opt_code code = (enum opt_code) scode;
 669
 670   switch (code)
 671     {
 672     default:
 673       abort ();
 674
 675     case OPT__help:
 676       print_help ();
 677       exit_after_options = true;
 678       break;
 679
 680     case OPT__param:
 681       handle_param (arg);
 682       break;
 683
 684     case OPT__target_help:
 685       display_target_options ();
 686       exit_after_options = true;
 687       break;
 688
 689     case OPT__version:
 690       print_version (stderr, "");
 691       exit_after_options = true;
 692       break;
 693
 694     case OPT_G:
 695       g_switch_value = value;
 696       g_switch_set = true;
 697       break;
 698
 699     case OPT_O:
 700     case OPT_Os:
 701       /* Currently handled in a prescan.  */
 702       break;
 703
 704     case OPT_W:
 705       /* For backward compatibility, -W is the same as -Wextra.  */
 706       set_Wextra (value);
 707       break;
 708
 709     case OPT_Waggregate_return:
 710       warn_aggregate_return = value;
 711       break;
 712
 713     case OPT_Wcast_align:
 714       warn_cast_align = value;
 715       break;
 716
 717     case OPT_Wdeprecated_declarations:
 718       warn_deprecated_decl = value;
 719       break;
 720
 721     case OPT_Wdisabled_optimization:
 722       warn_disabled_optimization = value;
 723       break;
 724
 725     case OPT_Werror:
 726       warnings_are_errors = value;
 727       break;
 728
 729     case OPT_Wextra:
 730       set_Wextra (value);
 731       break;
 732
 733     case OPT_Winline:
 734       warn_inline = value;
 735       break;
 736
 737     case OPT_Wlarger_than_:
 738       larger_than_size = value;
 739       warn_larger_than = value != -1;
 740       break;
 741
 742     case OPT_Wmissing_noreturn:
 743       warn_missing_noreturn = value;
 744       break;
 745
 746     case OPT_Wpacked:
 747       warn_packed = value;
 748       break;
 749
 750     case OPT_Wpadded:
 751       warn_padded = value;
 752       break;
 753
 754     case OPT_Wshadow:
 755       warn_shadow = value;
 756       break;
 757
 758     case OPT_Wstrict_aliasing:
 759     case OPT_Wstrict_aliasing_:
 760       warn_strict_aliasing = value;
 761       break;
 762
 763     case OPT_Wswitch:
 764       warn_switch = value;
 765       break;
 766
 767     case OPT_Wswitch_default:
 768       warn_switch_default = value;
 769       break;
 770
 771     case OPT_Wswitch_enum:
 772       warn_switch_enum = value;
 773       break;
 774
 775     case OPT_Wsystem_headers:
 776       warn_system_headers = value;
 777       break;
 778
 779     case OPT_Wuninitialized:
 780       warn_uninitialized = value;
 781       break;
 782
 783     case OPT_Wunreachable_code:
 784       warn_notreached = value;
 785       break;
 786
 787     case OPT_Wunused:
 788       set_Wunused (value);
 789       break;
 790
 791     case OPT_Wunused_function:
 792       warn_unused_function = value;
 793       break;
 794
 795     case OPT_Wunused_label:
 796       warn_unused_label = value;
 797       break;
 798
 799     case OPT_Wunused_parameter:
 800       warn_unused_parameter = value;
 801       break;
 802
 803     case OPT_Wunused_value:
 804       warn_unused_value = value;
 805       break;
 806
 807     case OPT_Wunused_variable:
 808       warn_unused_variable = value;
 809       break;
 810
 811     case OPT_aux_info:
 812     case OPT_aux_info_:
 813       aux_info_file_name = arg;
 814       flag_gen_aux_info = 1;
 815       break;
 816
 817     case OPT_auxbase:
 818       aux_base_name = arg;
 819       break;
 820
 821     case OPT_auxbase_strip:
 822       {
 823         char *tmp = xstrdup (arg);
 824         strip_off_ending (tmp, strlen (tmp));
 825         if (tmp[0])
 826           aux_base_name = tmp;
 827       }
 828       break;
 829
 830     case OPT_d:
 831       decode_d_option (arg);
 832       break;
 833
 834     case OPT_dumpbase:
 835       dump_base_name = arg;
 836       break;
 837
 838     case OPT_fPIC:
 839       flag_pic = value + value;
 840       break;
 841
 842     case OPT_fPIE:
 843       flag_pie = value + value;
 844       break;
 845
 846     case OPT_fabi_version_:
 847       flag_abi_version = value;
 848       break;
 849
 850     case OPT_falign_functions:
 851       align_functions = !value;
 852       break;
 853
 854     case OPT_falign_functions_:
 855       align_functions = value;
 856       break;
 857
 858     case OPT_falign_jumps:
 859       align_jumps = !value;
 860       break;
 861
 862     case OPT_falign_jumps_:
 863       align_jumps = value;
 864       break;
 865
 866     case OPT_falign_labels:
 867       align_labels = !value;
 868       break;
 869
 870     case OPT_falign_labels_:
 871       align_labels = value;
 872       break;
 873
 874     case OPT_falign_loops:
 875       align_loops = !value;
 876       break;
 877
 878     case OPT_falign_loops_:
 879       align_loops = value;
 880       break;
 881
 882     case OPT_fargument_alias:
 883       flag_argument_noalias = !value;
 884       break;
 885
 886     case OPT_fargument_noalias:
 887       flag_argument_noalias = value;
 888       break;
 889
 890     case OPT_fargument_noalias_global:
 891       flag_argument_noalias = value + value;
 892       break;
 893
 894     case OPT_fasynchronous_unwind_tables:
 895       flag_asynchronous_unwind_tables = value;
 896       break;
 897
 898     case OPT_fbounds_check:
 899       flag_bounds_check = value;
 900       break;
 901
 902     case OPT_fbranch_count_reg:
 903       flag_branch_on_count_reg = value;
 904       break;
 905
 906     case OPT_fbranch_probabilities:
 907       flag_branch_probabilities_set = true;
 908       flag_branch_probabilities = value;
 909       break;
 910
 911     case OPT_fbranch_target_load_optimize:
 912       flag_branch_target_load_optimize = value;
 913       break;
 914
 915     case OPT_fbranch_target_load_optimize2:
 916       flag_branch_target_load_optimize2 = value;
 917       break;
 918
 919     case OPT_fbtr_bb_exclusive:
 920       flag_btr_bb_exclusive = value;
 921       break;
 922
 923     case OPT_fcall_used_:
 924       fix_register (arg, 0, 1);
 925       break;
 926
 927     case OPT_fcall_saved_:
 928       fix_register (arg, 0, 0);
 929       break;
 930
 931     case OPT_fcaller_saves:
 932       flag_caller_saves = value;
 933       break;
 934
 935     case OPT_fcommon:
 936       flag_no_common = !value;
 937       break;
 938
 939     case OPT_fcprop_registers:
 940       flag_cprop_registers = value;
 941       break;
 942
 943     case OPT_fcrossjumping:
 944       flag_crossjumping = value;
 945       break;
 946
 947     case OPT_fcse_follow_jumps:
 948       flag_cse_follow_jumps = value;
 949       break;
 950
 951     case OPT_fcse_skip_blocks:
 952       flag_cse_skip_blocks = value;
 953       break;
 954
 955     case OPT_fdata_sections:
 956       flag_data_sections = value;
 957       break;
 958
 959     case OPT_fdefer_pop:
 960       flag_defer_pop = value;
 961       break;
 962
 963     case OPT_fdelayed_branch:
 964       flag_delayed_branch = value;
 965       break;
 966
 967     case OPT_fdelete_null_pointer_checks:
 968       flag_delete_null_pointer_checks = value;
 969       break;
 970
 971     case OPT_fdiagnostics_show_location_:
 972       if (!strcmp (arg, "once"))
 973         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 974       else if (!strcmp (arg, "every-line"))
 975         diagnostic_prefixing_rule (global_dc)
 976           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
 977       else
 978         return 0;
 979       break;
 980
 981     case OPT_fdump_unnumbered:
 982       flag_dump_unnumbered = value;
 983       break;
 984
 985     case OPT_feliminate_dwarf2_dups:
 986       flag_eliminate_dwarf2_dups = value;
 987       break;
 988
 989     case OPT_feliminate_unused_debug_types:
 990       flag_eliminate_unused_debug_types = value;
 991       break;
 992
 993     case OPT_feliminate_unused_debug_symbols:
 994       flag_debug_only_used_symbols = value;
 995       break;
 996
 997     case OPT_fexceptions:
 998       flag_exceptions = value;
 999       break;
1000
1001     case OPT_fexpensive_optimizations:
1002       flag_expensive_optimizations = value;
1003       break;
1004
1005     case OPT_ffast_math:
1006       set_fast_math_flags (value);
1007       break;
1008
1009     case OPT_ffinite_math_only:
1010       flag_finite_math_only = value;
1011       break;
1012
1013     case OPT_ffixed_:
1014       fix_register (arg, 1, 1);
1015       break;
1016
1017     case OPT_ffunction_cse:
1018       flag_no_function_cse = !value;
1019       break;
1020
1021     case OPT_ffloat_store:
1022       flag_float_store = value;
1023       break;
1024
1025     case OPT_fforce_addr:
1026       flag_force_addr = value;
1027       break;
1028
1029     case OPT_fforce_mem:
1030       flag_force_mem = value;
1031       break;
1032
1033     case OPT_ffunction_sections:
1034       flag_function_sections = value;
1035       break;
1036
1037     case OPT_fgcse:
1038       flag_gcse = value;
1039       break;
1040
1041     case OPT_fgcse_lm:
1042       flag_gcse_lm = value;
1043       break;
1044
1045     case OPT_fgcse_sm:
1046       flag_gcse_sm = value;
1047       break;
1048
1049     case OPT_fgcse_after_reload:
1050       flag_gcse_after_reload = value;
1051       break;
1052
1053     case OPT_fgcse_las:
1054       flag_gcse_las = value;
1055       break;
1056
1057     case OPT_fguess_branch_probability:
1058       flag_guess_branch_prob = value;
1059       break;
1060
1061     case OPT_fident:
1062       flag_no_ident = !value;
1063       break;
1064
1065     case OPT_fif_conversion:
1066       flag_if_conversion = value;
1067       break;
1068
1069     case OPT_fif_conversion2:
1070       flag_if_conversion2 = value;
1071       break;
1072
1073     case OPT_finhibit_size_directive:
1074       flag_inhibit_size_directive = value;
1075       break;
1076
1077     case OPT_finline:
1078       flag_no_inline = !value;
1079       break;
1080
1081     case OPT_finline_functions:
1082       flag_inline_functions = value;
1083       break;
1084
1085     case OPT_finline_limit_:
1086     case OPT_finline_limit_eq:
1087       set_param_value ("max-inline-insns-single", value / 2);
1088       set_param_value ("max-inline-insns-auto", value / 2);
1089       set_param_value ("max-inline-insns-rtl", value);
1090       break;
1091
1092     case OPT_finstrument_functions:
1093       flag_instrument_function_entry_exit = value;
1094       break;
1095
1096     case OPT_fkeep_inline_functions:
1097       flag_keep_inline_functions =value;
1098       break;
1099
1100     case OPT_fkeep_static_consts:
1101       flag_keep_static_consts = value;
1102       break;
1103
1104     case OPT_fleading_underscore:
1105       flag_leading_underscore = value;
1106       break;
1107
1108     case OPT_floop_optimize:
1109       flag_loop_optimize = value;
1110       break;
1111
1112     case OPT_fmath_errno:
1113       flag_errno_math = value;
1114       break;
1115
1116     case OPT_fmem_report:
1117       mem_report = value;
1118       break;
1119
1120     case OPT_fmerge_all_constants:
1121       flag_merge_constants = value + value;
1122       break;
1123
1124     case OPT_fmerge_constants:
1125       flag_merge_constants = value;
1126       break;
1127
1128     case OPT_fmessage_length_:
1129       pp_set_line_maximum_length (global_dc->printer, value);
1130       break;
1131
1132     case OPT_fmove_all_movables:
1133       flag_move_all_movables = value;
1134       break;
1135
1136     case OPT_fnew_ra:
1137       flag_new_regalloc = value;
1138       break;
1139
1140     case OPT_fnon_call_exceptions:
1141       flag_non_call_exceptions = value;
1142       break;
1143
1144     case OPT_fold_unroll_all_loops:
1145       flag_old_unroll_all_loops = value;
1146       break;
1147
1148     case OPT_fold_unroll_loops:
1149       flag_old_unroll_loops = value;
1150       break;
1151
1152     case OPT_fomit_frame_pointer:
1153       flag_omit_frame_pointer = value;
1154       break;
1155
1156     case OPT_foptimize_register_move:
1157       flag_regmove = value;
1158       break;
1159
1160     case OPT_foptimize_sibling_calls:
1161       flag_optimize_sibling_calls = value;
1162       break;
1163
1164     case OPT_fpack_struct:
1165       flag_pack_struct = value;
1166       break;
1167
1168     case OPT_fpeel_loops:
1169       flag_peel_loops_set = true;
1170       flag_peel_loops = value;
1171       break;
1172
1173     case OPT_fpcc_struct_return:
1174       flag_pcc_struct_return = value;
1175       break;
1176
1177     case OPT_fpeephole:
1178       flag_no_peephole = !value;
1179       break;
1180
1181     case OPT_fpeephole2:
1182       flag_peephole2 = value;
1183       break;
1184
1185     case OPT_fpic:
1186       flag_pic = value;
1187       break;
1188
1189     case OPT_fpie:
1190       flag_pie = value;
1191       break;
1192
1193     case OPT_fprefetch_loop_arrays:
1194       flag_prefetch_loop_arrays = value;
1195       break;
1196
1197     case OPT_fprofile:
1198       profile_flag = value;
1199       break;
1200
1201     case OPT_fprofile_arcs:
1202       profile_arc_flag_set = true;
1203       profile_arc_flag = value;
1204       break;
1205
1206     case OPT_fprofile_use:
1207       if (!flag_branch_probabilities_set)
1208         flag_branch_probabilities = value;
1209       if (!flag_profile_values_set)
1210         flag_profile_values = value;
1211       if (!flag_unroll_loops_set)
1212         flag_unroll_loops = value;
1213       if (!flag_peel_loops_set)
1214         flag_peel_loops = value;
1215       if (!flag_tracer_set)
1216         flag_tracer = value;
1217       if (!flag_value_profile_transformations_set)
1218         flag_value_profile_transformations = value;
1219       break;
1220
1221     case OPT_fprofile_generate:
1222       if (!profile_arc_flag_set)
1223         profile_arc_flag = value;
1224       if (!flag_profile_values_set)
1225         flag_profile_values = value;
1226       if (!flag_value_profile_transformations_set)
1227         flag_value_profile_transformations = value;
1228       break;
1229
1230     case OPT_fprofile_values:
1231       flag_profile_values_set = true;
1232       flag_profile_values = value;
1233       break;
1234
1235     case OPT_fvpt:
1236       flag_value_profile_transformations_set = value;
1237       flag_value_profile_transformations = value;
1238       break;
1239
1240     case OPT_frandom_seed:
1241       /* The real switch is -fno-random-seed.  */
1242       if (value)
1243         return 0;
1244       flag_random_seed = NULL;
1245       break;
1246
1247     case OPT_frandom_seed_:
1248       flag_random_seed = arg;
1249       break;
1250
1251     case OPT_freduce_all_givs:
1252       flag_reduce_all_givs = value;
1253       break;
1254
1255     case OPT_freg_struct_return:
1256       flag_pcc_struct_return = !value;
1257       break;
1258
1259     case OPT_fregmove:
1260       flag_regmove = value;
1261       break;
1262
1263     case OPT_frename_registers:
1264       flag_rename_registers = value;
1265       break;
1266
1267     case OPT_freorder_blocks:
1268       flag_reorder_blocks = value;
1269       break;
1270
1271     case OPT_freorder_functions:
1272       flag_reorder_functions = value;
1273       break;
1274
1275     case OPT_frerun_cse_after_loop:
1276       flag_rerun_cse_after_loop = value;
1277       break;
1278
1279     case OPT_frerun_loop_opt:
1280       flag_rerun_loop_opt = value;
1281       break;
1282
1283     case OPT_frounding_math:
1284       flag_rounding_math = value;
1285       break;
1286
1287     case OPT_fsched_interblock:
1288       flag_schedule_interblock = value;
1289       break;
1290
1291     case OPT_fsched_spec:
1292       flag_schedule_speculative = value;
1293       break;
1294
1295     case OPT_fsched_spec_load:
1296       flag_schedule_speculative_load = value;
1297       break;
1298
1299     case OPT_fsched_spec_load_dangerous:
1300       flag_schedule_speculative_load_dangerous = value;
1301       break;
1302
1303     case OPT_fsched_verbose_:
1304 #ifdef INSN_SCHEDULING
1305       fix_sched_param ("verbose", arg);
1306       break;
1307 #else
1308       return 0;
1309 #endif
1310
1311     case OPT_fsched2_use_superblocks:
1312       flag_sched2_use_superblocks = value;
1313       break;
1314
1315     case OPT_fsched2_use_traces:
1316       flag_sched2_use_traces = value;
1317       break;
1318
1319     case OPT_fschedule_insns:
1320       flag_schedule_insns = value;
1321       break;
1322
1323     case OPT_fschedule_insns2:
1324       flag_schedule_insns_after_reload = value;
1325       break;
1326
1327     case OPT_fsched_stalled_insns:
1328       flag_sched_stalled_insns = value;
1329       break;
1330
1331     case OPT_fsched_stalled_insns_:
1332       flag_sched_stalled_insns = value;
1333       if (flag_sched_stalled_insns == 0)
1334         flag_sched_stalled_insns = -1;
1335       break;
1336
1337     case OPT_fsched_stalled_insns_dep:
1338       flag_sched_stalled_insns_dep = 1;
1339       break;
1340
1341     case OPT_fsched_stalled_insns_dep_:
1342       flag_sched_stalled_insns_dep = value;
1343       break;
1344
1345     case OPT_fshared_data:
1346       flag_shared_data = value;
1347       break;
1348
1349     case OPT_fsignaling_nans:
1350       flag_signaling_nans = value;
1351       break;
1352
1353     case OPT_fsingle_precision_constant:
1354       flag_single_precision_constant = value;
1355       break;
1356
1357     case OPT_fstack_check:
1358       flag_stack_check = value;
1359       break;
1360
1361     case OPT_fstack_limit:
1362       /* The real switch is -fno-stack-limit.  */
1363       if (value)
1364         return 0;
1365       stack_limit_rtx = NULL_RTX;
1366       break;
1367
1368     case OPT_fstack_limit_register_:
1369       {
1370         int reg = decode_reg_name (arg);
1371         if (reg < 0)
1372           error ("unrecognized register name \"%s\"", arg);
1373         else
1374           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1375       }
1376       break;
1377
1378     case OPT_fstack_limit_symbol_:
1379       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1380       break;
1381
1382     case OPT_fstrength_reduce:
1383       flag_strength_reduce = value;
1384       break;
1385
1386     case OPT_fstrict_aliasing:
1387       flag_strict_aliasing = value;
1388       break;
1389
1390     case OPT_fsyntax_only:
1391       flag_syntax_only = value;
1392       break;
1393
1394     case OPT_ftest_coverage:
1395       flag_test_coverage = value;
1396       break;
1397
1398     case OPT_fthread_jumps:
1399       flag_thread_jumps = value;
1400       break;
1401
1402     case OPT_ftime_report:
1403       time_report = value;
1404       break;
1405
1406     case OPT_ftls_model_:
1407       if (!strcmp (arg, "global-dynamic"))
1408         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1409       else if (!strcmp (arg, "local-dynamic"))
1410         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1411       else if (!strcmp (arg, "initial-exec"))
1412         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1413       else if (!strcmp (arg, "local-exec"))
1414         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1415       else
1416         warning ("unknown tls-model \"%s\"", arg);
1417       break;
1418
1419     case OPT_ftracer:
1420       flag_tracer_set = true;
1421       flag_tracer = value;
1422       break;
1423
1424     case OPT_ftrapping_math:
1425       flag_trapping_math = value;
1426       break;
1427
1428     case OPT_ftrapv:
1429       flag_trapv = value;
1430       break;
1431
1432     case OPT_funit_at_a_time:
1433       flag_unit_at_a_time = value;
1434       break;
1435
1436     case OPT_funroll_all_loops:
1437       flag_unroll_all_loops = value;
1438       break;
1439
1440     case OPT_funroll_loops:
1441       flag_unroll_loops_set = true;
1442       flag_unroll_loops = value;
1443       break;
1444
1445     case OPT_funsafe_math_optimizations:
1446       flag_unsafe_math_optimizations = value;
1447       break;
1448
1449     case OPT_funswitch_loops:
1450       flag_unswitch_loops = value;
1451       break;
1452
1453     case OPT_funwind_tables:
1454       flag_unwind_tables = value;
1455       break;
1456
1457     case OPT_fvar_tracking:
1458       flag_var_tracking = value;
1459       break;
1460
1461     case OPT_fverbose_asm:
1462       flag_verbose_asm = value;
1463       break;
1464
1465     case OPT_fweb:
1466       flag_web = value;
1467       break;
1468
1469     case OPT_fwrapv:
1470       flag_wrapv = value;
1471       break;
1472
1473     case OPT_fzero_initialized_in_bss:
1474       flag_zero_initialized_in_bss = value;
1475       break;
1476
1477     case OPT_g:
1478       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
1479       break;
1480
1481     case OPT_gcoff:
1482       set_debug_level (SDB_DEBUG, false, arg);
1483       break;
1484
1485     case OPT_gdwarf_2:
1486       set_debug_level (DWARF2_DEBUG, false, arg);
1487       break;
1488
1489     case OPT_ggdb:
1490       set_debug_level (NO_DEBUG, 2, arg);
1491       break;
1492
1493     case OPT_gstabs:
1494     case OPT_gstabs_:
1495       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
1496       break;
1497
1498     case OPT_gvms:
1499       set_debug_level (VMS_DEBUG, false, arg);
1500       break;
1501
1502     case OPT_gxcoff:
1503     case OPT_gxcoff_:
1504       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
1505       break;
1506
1507     case OPT_m:
1508       set_target_switch (arg);
1509       break;
1510
1511     case OPT_o:
1512       asm_file_name = arg;
1513       break;
1514
1515     case OPT_p:
1516       profile_flag = 1;
1517       break;
1518
1519     case OPT_pedantic:
1520       pedantic = 1;
1521       break;
1522
1523     case OPT_pedantic_errors:
1524       flag_pedantic_errors = pedantic = 1;
1525       break;
1526
1527     case OPT_quiet:
1528       quiet_flag = 1;
1529       break;
1530
1531     case OPT_version:
1532       version_flag = 1;
1533       break;
1534
1535     case OPT_w:
1536       inhibit_warnings = true;
1537       break;
1538     }
1539
1540   return 1;
1541 }
1542
1543 /* Handle --param NAME=VALUE.  */
1544 static void
1545 handle_param (const char *carg)
1546 {
1547   char *equal, *arg;
1548   int value;
1549
1550   arg = xstrdup (carg);
1551   equal = strchr (arg, '=');
1552   if (!equal)
1553     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1554   else
1555     {
1556       value = integral_argument (equal + 1);
1557       if (value == -1)
1558         error ("invalid --param value `%s'", equal + 1);
1559       else
1560         {
1561           *equal = '\0';
1562           set_param_value (arg, value);
1563         }
1564     }
1565
1566   free (arg);
1567 }
1568
1569 /* Handle -W and -Wextra.  */
1570 static void
1571 set_Wextra (int setting)
1572 {
1573   extra_warnings = setting;
1574   warn_unused_value = setting;
1575   warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1576
1577   /* We save the value of warn_uninitialized, since if they put
1578      -Wuninitialized on the command line, we need to generate a
1579      warning about not using it without also specifying -O.  */
1580   if (setting == 0)
1581     warn_uninitialized = 0;
1582   else if (warn_uninitialized != 1)
1583     warn_uninitialized = 2;
1584 }
1585
1586 /* Initialize unused warning flags.  */
1587 void
1588 set_Wunused (int setting)
1589 {
1590   warn_unused_function = setting;
1591   warn_unused_label = setting;
1592   /* Unused function parameter warnings are reported when either
1593      ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1594      Thus, if -Wextra has already been seen, set warn_unused_parameter;
1595      otherwise set maybe_warn_extra_parameter, which will be picked up
1596      by set_Wextra.  */
1597   maybe_warn_unused_parameter = setting;
1598   warn_unused_parameter = (setting && extra_warnings);
1599   warn_unused_variable = setting;
1600   warn_unused_value = setting;
1601 }
1602
1603 /* The following routines are useful in setting all the flags that
1604    -ffast-math and -fno-fast-math imply.  */
1605 void
1606 set_fast_math_flags (int set)
1607 {
1608   flag_trapping_math = !set;
1609   flag_unsafe_math_optimizations = set;
1610   flag_finite_math_only = set;
1611   flag_errno_math = !set;
1612   if (set)
1613     {
1614       flag_signaling_nans = 0;
1615       flag_rounding_math = 0;
1616     }
1617 }
1618
1619 /* Return true iff flags are set as if -ffast-math.  */
1620 bool
1621 fast_math_flags_set_p (void)
1622 {
1623   return (!flag_trapping_math
1624           && flag_unsafe_math_optimizations
1625           && flag_finite_math_only
1626           && !flag_errno_math);
1627 }
1628
1629 /* Handle a debug output -g switch.  EXTENDED is true or false to support
1630    extended output (2 is special and means "-ggdb" was given).  */
1631 static void
1632 set_debug_level (enum debug_info_type type, int extended, const char *arg)
1633 {
1634   static bool type_explicit;
1635
1636   use_gnu_debug_info_extensions = extended;
1637
1638   if (type == NO_DEBUG)
1639     {
1640       if (write_symbols == NO_DEBUG)
1641         {
1642           write_symbols = PREFERRED_DEBUGGING_TYPE;
1643
1644           if (extended == 2)
1645             {
1646 #ifdef DWARF2_DEBUGGING_INFO
1647               write_symbols = DWARF2_DEBUG;
1648 #elif defined DBX_DEBUGGING_INFO
1649               write_symbols = DBX_DEBUG;
1650 #endif
1651             }
1652
1653           if (write_symbols == NO_DEBUG)
1654             warning ("target system does not support debug output");
1655         }
1656     }
1657   else
1658     {
1659       /* Does it conflict with an already selected type?  */
1660       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1661         error ("debug format \"%s\" conflicts with prior selection",
1662                debug_type_names[type]);
1663       write_symbols = type;
1664       type_explicit = true;
1665     }
1666
1667   /* A debug flag without a level defaults to level 2.  */
1668   if (*arg == '\0')
1669     {
1670       if (!debug_info_level)
1671         debug_info_level = 2;
1672     }
1673   else
1674     {
1675       debug_info_level = integral_argument (arg);
1676       if (debug_info_level == (unsigned int) -1)
1677         error ("unrecognised debug output level \"%s\"", arg);
1678       else if (debug_info_level > 3)
1679         error ("debug output level %s is too high", arg);
1680     }
1681 }
1682
1683 /* Output --help text.  */
1684 static void
1685 print_help (void)
1686 {
1687   size_t i;
1688   const char *p;
1689
1690   GET_ENVIRONMENT (p, "COLUMNS");
1691   if (p)
1692     {
1693       int value = atoi (p);
1694       if (value > 0)
1695         columns = value;
1696     }
1697
1698   puts (_("The following options are language-independent:\n"));
1699
1700   print_filtered_help (CL_COMMON);
1701   print_param_help ();
1702
1703   for (i = 0; lang_names[i]; i++)
1704     {
1705       printf (_("The %s front end recognizes the following options:\n\n"),
1706               lang_names[i]);
1707       print_filtered_help (1U << i);
1708     }
1709
1710   display_target_options ();
1711 }
1712
1713 /* Print the help for --param.  */
1714 static void
1715 print_param_help (void)
1716 {
1717   size_t i;
1718
1719   puts (_("The --param option recognizes the following as parameters:\n"));
1720
1721   for (i = 0; i < LAST_PARAM; i++)
1722     {
1723       const char *help = compiler_params[i].help;
1724       const char *param = compiler_params[i].option;
1725
1726       if (help == NULL || *help == '\0')
1727         help = undocumented_msg;
1728
1729       /* Get the translation.  */
1730       help = _(help);
1731
1732       wrap_help (help, param, strlen (param));
1733     }
1734
1735   putchar ('\n');
1736 }
1737
1738 /* Print help for a specific front-end, etc.  */
1739 static void
1740 print_filtered_help (unsigned int flag)
1741 {
1742   unsigned int i, len, filter, indent = 0;
1743   bool duplicates = false;
1744   const char *help, *opt, *tab;
1745   static char *printed;
1746
1747   if (flag == CL_COMMON)
1748     {
1749       filter = flag;
1750       if (!printed)
1751         printed = xmalloc (cl_options_count);
1752       memset (printed, 0, cl_options_count);
1753     }
1754   else
1755     {
1756       /* Don't print COMMON options twice.  */
1757       filter = flag | CL_COMMON;
1758
1759       for (i = 0; i < cl_options_count; i++)
1760         {
1761           if ((cl_options[i].flags & filter) != flag)
1762             continue;
1763
1764           /* Skip help for internal switches.  */
1765           if (cl_options[i].flags & CL_UNDOCUMENTED)
1766             continue;
1767
1768           /* Skip switches that have already been printed, mark them to be
1769              listed later.  */
1770           if (printed[i])
1771             {
1772               duplicates = true;
1773               indent = print_switch (cl_options[i].opt_text, indent);
1774             }
1775         }
1776
1777       if (duplicates)
1778         {
1779           putchar ('\n');
1780           putchar ('\n');
1781         }
1782     }
1783
1784   for (i = 0; i < cl_options_count; i++)
1785     {
1786       if ((cl_options[i].flags & filter) != flag)
1787         continue;
1788
1789       /* Skip help for internal switches.  */
1790       if (cl_options[i].flags & CL_UNDOCUMENTED)
1791         continue;
1792
1793       /* Skip switches that have already been printed.  */
1794       if (printed[i])
1795         continue;
1796
1797       printed[i] = true;
1798
1799       help = cl_options[i].help;
1800       if (!help)
1801         help = undocumented_msg;
1802
1803       /* Get the translation.  */
1804       help = _(help);
1805
1806       tab = strchr (help, '\t');
1807       if (tab)
1808         {
1809           len = tab - help;
1810           opt = help;
1811           help = tab + 1;
1812         }
1813       else
1814         {
1815           opt = cl_options[i].opt_text;
1816           len = strlen (opt);
1817         }
1818
1819       wrap_help (help, opt, len);
1820     }
1821
1822   putchar ('\n');
1823 }
1824
1825 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1826    word-wrapped HELP in a second column.  */
1827 static unsigned int
1828 print_switch (const char *text, unsigned int indent)
1829 {
1830   unsigned int len = strlen (text) + 1; /* trailing comma */
1831
1832   if (indent)
1833     {
1834       putchar (',');
1835       if (indent + len > columns)
1836         {
1837           putchar ('\n');
1838           putchar (' ');
1839           indent = 1;
1840         }
1841     }
1842   else
1843     putchar (' ');
1844
1845   putchar (' ');
1846   fputs (text, stdout);
1847
1848   return indent + len + 1;
1849 }
1850
1851 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1852    word-wrapped HELP in a second column.  */
1853 static void
1854 wrap_help (const char *help, const char *item, unsigned int item_width)
1855 {
1856   unsigned int col_width = 27;
1857   unsigned int remaining, room, len;
1858
1859   remaining = strlen (help);
1860
1861   do
1862     {
1863       room = columns - 3 - MAX (col_width, item_width);
1864       if (room > columns)
1865         room = 0;
1866       len = remaining;
1867
1868       if (room < len)
1869         {
1870           unsigned int i;
1871
1872           for (i = 0; help[i]; i++)
1873             {
1874               if (i >= room && len != remaining)
1875                 break;
1876               if (help[i] == ' ')
1877                 len = i;
1878               else if ((help[i] == '-' || help[i] == '/')
1879                        && help[i + 1] != ' '
1880                        && i > 0 && ISALPHA (help[i - 1]))
1881                 len = i + 1;
1882             }
1883         }
1884
1885       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1886       item_width = 0;
1887       while (help[len] == ' ')
1888         len++;
1889       help += len;
1890       remaining -= len;
1891     }
1892   while (remaining);
1893 }