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