gcc/opts.c

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