gcc/opts.c

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