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             free (new_option);
 793           }
 794       }
 795       break;
 796
 797     case OPT_Wextra:
 798       set_Wextra (value);
 799       break;
 800
 801     case OPT_Wlarger_than_:
 802       larger_than_size = value;
 803       warn_larger_than = value != -1;
 804       break;
 805
 806     case OPT_Wstrict_aliasing:
 807     case OPT_Wstrict_aliasing_:
 808       warn_strict_aliasing = value;
 809       break;
 810
 811     case OPT_Wunused:
 812       set_Wunused (value);
 813       break;
 814
 815     case OPT_aux_info:
 816     case OPT_aux_info_:
 817       aux_info_file_name = arg;
 818       flag_gen_aux_info = 1;
 819       break;
 820
 821     case OPT_auxbase:
 822       aux_base_name = arg;
 823       break;
 824
 825     case OPT_auxbase_strip:
 826       {
 827         char *tmp = xstrdup (arg);
 828         strip_off_ending (tmp, strlen (tmp));
 829         if (tmp[0])
 830           aux_base_name = tmp;
 831       }
 832       break;
 833
 834     case OPT_d:
 835       decode_d_option (arg);
 836       break;
 837
 838     case OPT_dumpbase:
 839       dump_base_name = arg;
 840       break;
 841
 842     case OPT_falign_functions_:
 843       align_functions = value;
 844       break;
 845
 846     case OPT_falign_jumps_:
 847       align_jumps = value;
 848       break;
 849
 850     case OPT_falign_labels_:
 851       align_labels = value;
 852       break;
 853
 854     case OPT_falign_loops_:
 855       align_loops = value;
 856       break;
 857
 858     case OPT_fbranch_probabilities:
 859       flag_branch_probabilities_set = true;
 860       break;
 861
 862     case OPT_floop_optimize:
 863       flag_loop_optimize_set = true;
 864       break;
 865
 866     case OPT_fcall_used_:
 867       fix_register (arg, 0, 1);
 868       break;
 869
 870     case OPT_fcall_saved_:
 871       fix_register (arg, 0, 0);
 872       break;
 873
 874     case OPT_fdiagnostics_show_location_:
 875       if (!strcmp (arg, "once"))
 876         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 877       else if (!strcmp (arg, "every-line"))
 878         diagnostic_prefixing_rule (global_dc)
 879           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
 880       else
 881         return 0;
 882       break;
 883
 884     case OPT_fdiagnostics_show_option:
 885       global_dc->show_option_requested = true;
 886       break;
 887
 888     case OPT_fdump_:
 889       if (!dump_switch_p (arg))
 890         return 0;
 891       break;
 892
 893     case OPT_ffast_math:
 894       set_fast_math_flags (value);
 895       break;
 896
 897     case OPT_ffixed_:
 898       fix_register (arg, 1, 1);
 899       break;
 900
 901     case OPT_finline_limit_:
 902     case OPT_finline_limit_eq:
 903       set_param_value ("max-inline-insns-single", value / 2);
 904       set_param_value ("max-inline-insns-auto", value / 2);
 905       break;
 906
 907     case OPT_fmessage_length_:
 908       pp_set_line_maximum_length (global_dc->printer, value);
 909       break;
 910
 911     case OPT_fpack_struct_:
 912       if (value <= 0 || (value & (value - 1)) || value > 16)
 913         error("structure alignment must be a small power of two, not %d", value);
 914       else
 915         {
 916           initial_max_fld_align = value;
 917           maximum_field_alignment = value * BITS_PER_UNIT;
 918         }
 919       break;
 920
 921     case OPT_fpeel_loops:
 922       flag_peel_loops_set = true;
 923       break;
 924
 925     case OPT_fprofile_arcs:
 926       profile_arc_flag_set = true;
 927       break;
 928
 929     case OPT_fprofile_use:
 930       if (!flag_branch_probabilities_set)
 931         flag_branch_probabilities = value;
 932       if (!flag_profile_values_set)
 933         flag_profile_values = value;
 934       if (!flag_unroll_loops_set)
 935         flag_unroll_loops = value;
 936       if (!flag_peel_loops_set)
 937         flag_peel_loops = value;
 938       if (!flag_tracer_set)
 939         flag_tracer = value;
 940       if (!flag_value_profile_transformations_set)
 941         flag_value_profile_transformations = value;
 942       /* Old loop optimizer is incompatible with tree profiling.  */
 943       if (!flag_loop_optimize_set)
 944         flag_loop_optimize = 0;
 945       break;
 946
 947     case OPT_fprofile_generate:
 948       if (!profile_arc_flag_set)
 949         profile_arc_flag = value;
 950       if (!flag_profile_values_set)
 951         flag_profile_values = value;
 952       if (!flag_value_profile_transformations_set)
 953         flag_value_profile_transformations = value;
 954       break;
 955
 956     case OPT_fprofile_values:
 957       flag_profile_values_set = true;
 958       break;
 959
 960     case OPT_fvisibility_:
 961       {
 962         if (!strcmp(arg, "default"))
 963           default_visibility = VISIBILITY_DEFAULT;
 964         else if (!strcmp(arg, "internal"))
 965           default_visibility = VISIBILITY_INTERNAL;
 966         else if (!strcmp(arg, "hidden"))
 967           default_visibility = VISIBILITY_HIDDEN;
 968         else if (!strcmp(arg, "protected"))
 969           default_visibility = VISIBILITY_PROTECTED;
 970         else
 971           error ("unrecognized visibility value \"%s\"", arg);
 972       }
 973       break;
 974
 975     case OPT_fvpt:
 976       flag_value_profile_transformations_set = true;
 977       break;
 978
 979     case OPT_frandom_seed:
 980       /* The real switch is -fno-random-seed.  */
 981       if (value)
 982         return 0;
 983       flag_random_seed = NULL;
 984       break;
 985
 986     case OPT_frandom_seed_:
 987       flag_random_seed = arg;
 988       break;
 989
 990     case OPT_fsched_verbose_:
 991 #ifdef INSN_SCHEDULING
 992       fix_sched_param ("verbose", arg);
 993       break;
 994 #else
 995       return 0;
 996 #endif
 997
 998     case OPT_fsched_stalled_insns_:
 999       flag_sched_stalled_insns = value;
1000       if (flag_sched_stalled_insns == 0)
1001         flag_sched_stalled_insns = -1;
1002       break;
1003
1004     case OPT_fsched_stalled_insns_dep_:
1005       flag_sched_stalled_insns_dep = value;
1006       break;
1007
1008     case OPT_fstack_limit:
1009       /* The real switch is -fno-stack-limit.  */
1010       if (value)
1011         return 0;
1012       stack_limit_rtx = NULL_RTX;
1013       break;
1014
1015     case OPT_fstack_limit_register_:
1016       {
1017         int reg = decode_reg_name (arg);
1018         if (reg < 0)
1019           error ("unrecognized register name \"%s\"", arg);
1020         else
1021           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1022       }
1023       break;
1024
1025     case OPT_fstack_limit_symbol_:
1026       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1027       break;
1028
1029     case OPT_ftree_vectorizer_verbose_:
1030       vect_set_verbosity_level (arg);
1031       break;
1032
1033     case OPT_ftls_model_:
1034       if (!strcmp (arg, "global-dynamic"))
1035         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1036       else if (!strcmp (arg, "local-dynamic"))
1037         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1038       else if (!strcmp (arg, "initial-exec"))
1039         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1040       else if (!strcmp (arg, "local-exec"))
1041         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1042       else
1043         warning (0, "unknown tls-model \"%s\"", arg);
1044       break;
1045
1046     case OPT_ftracer:
1047       flag_tracer_set = true;
1048       break;
1049
1050     case OPT_funroll_loops:
1051       flag_unroll_loops_set = true;
1052       break;
1053
1054     case OPT_g:
1055       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
1056       break;
1057
1058     case OPT_gcoff:
1059       set_debug_level (SDB_DEBUG, false, arg);
1060       break;
1061
1062     case OPT_gdwarf_2:
1063       set_debug_level (DWARF2_DEBUG, false, arg);
1064       break;
1065
1066     case OPT_ggdb:
1067       set_debug_level (NO_DEBUG, 2, arg);
1068       break;
1069
1070     case OPT_gstabs:
1071     case OPT_gstabs_:
1072       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
1073       break;
1074
1075     case OPT_gvms:
1076       set_debug_level (VMS_DEBUG, false, arg);
1077       break;
1078
1079     case OPT_gxcoff:
1080     case OPT_gxcoff_:
1081       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
1082       break;
1083
1084     case OPT_o:
1085       asm_file_name = arg;
1086       break;
1087
1088     case OPT_pedantic_errors:
1089       flag_pedantic_errors = pedantic = 1;
1090       break;
1091
1092     case OPT_fforce_mem:
1093       warning (0, "-f[no-]force-mem is nop and option will be removed in 4.2");
1094       break;
1095
1096     default:
1097       /* If the flag was handled in a standard way, assume the lack of
1098          processing here is intentional.  */
1099       gcc_assert (cl_options[scode].flag_var);
1100       break;
1101     }
1102
1103   return 1;
1104 }
1105
1106 /* Handle --param NAME=VALUE.  */
1107 static void
1108 handle_param (const char *carg)
1109 {
1110   char *equal, *arg;
1111   int value;
1112
1113   arg = xstrdup (carg);
1114   equal = strchr (arg, '=');
1115   if (!equal)
1116     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1117   else
1118     {
1119       value = integral_argument (equal + 1);
1120       if (value == -1)
1121         error ("invalid --param value %qs", equal + 1);
1122       else
1123         {
1124           *equal = '\0';
1125           set_param_value (arg, value);
1126         }
1127     }
1128
1129   free (arg);
1130 }
1131
1132 /* Handle -W and -Wextra.  */
1133 static void
1134 set_Wextra (int setting)
1135 {
1136   extra_warnings = setting;
1137   warn_unused_value = setting;
1138   warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1139
1140   /* We save the value of warn_uninitialized, since if they put
1141      -Wuninitialized on the command line, we need to generate a
1142      warning about not using it without also specifying -O.  */
1143   if (setting == 0)
1144     warn_uninitialized = 0;
1145   else if (warn_uninitialized != 1)
1146     warn_uninitialized = 2;
1147 }
1148
1149 /* Initialize unused warning flags.  */
1150 void
1151 set_Wunused (int setting)
1152 {
1153   warn_unused_function = setting;
1154   warn_unused_label = setting;
1155   /* Unused function parameter warnings are reported when either
1156      ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1157      Thus, if -Wextra has already been seen, set warn_unused_parameter;
1158      otherwise set maybe_warn_extra_parameter, which will be picked up
1159      by set_Wextra.  */
1160   maybe_warn_unused_parameter = setting;
1161   warn_unused_parameter = (setting && extra_warnings);
1162   warn_unused_variable = setting;
1163   warn_unused_value = setting;
1164 }
1165
1166 /* The following routines are useful in setting all the flags that
1167    -ffast-math and -fno-fast-math imply.  */
1168 void
1169 set_fast_math_flags (int set)
1170 {
1171   flag_trapping_math = !set;
1172   flag_unsafe_math_optimizations = set;
1173   flag_finite_math_only = set;
1174   flag_errno_math = !set;
1175   if (set)
1176     {
1177       flag_signaling_nans = 0;
1178       flag_rounding_math = 0;
1179       flag_cx_limited_range = 1;
1180     }
1181 }
1182
1183 /* Return true iff flags are set as if -ffast-math.  */
1184 bool
1185 fast_math_flags_set_p (void)
1186 {
1187   return (!flag_trapping_math
1188           && flag_unsafe_math_optimizations
1189           && flag_finite_math_only
1190           && !flag_errno_math);
1191 }
1192
1193 /* Handle a debug output -g switch.  EXTENDED is true or false to support
1194    extended output (2 is special and means "-ggdb" was given).  */
1195 static void
1196 set_debug_level (enum debug_info_type type, int extended, const char *arg)
1197 {
1198   static bool type_explicit;
1199
1200   use_gnu_debug_info_extensions = extended;
1201
1202   if (type == NO_DEBUG)
1203     {
1204       if (write_symbols == NO_DEBUG)
1205         {
1206           write_symbols = PREFERRED_DEBUGGING_TYPE;
1207
1208           if (extended == 2)
1209             {
1210 #ifdef DWARF2_DEBUGGING_INFO
1211               write_symbols = DWARF2_DEBUG;
1212 #elif defined DBX_DEBUGGING_INFO
1213               write_symbols = DBX_DEBUG;
1214 #endif
1215             }
1216
1217           if (write_symbols == NO_DEBUG)
1218             warning (0, "target system does not support debug output");
1219         }
1220     }
1221   else
1222     {
1223       /* Does it conflict with an already selected type?  */
1224       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1225         error ("debug format \"%s\" conflicts with prior selection",
1226                debug_type_names[type]);
1227       write_symbols = type;
1228       type_explicit = true;
1229     }
1230
1231   /* A debug flag without a level defaults to level 2.  */
1232   if (*arg == '\0')
1233     {
1234       if (!debug_info_level)
1235         debug_info_level = 2;
1236     }
1237   else
1238     {
1239       debug_info_level = integral_argument (arg);
1240       if (debug_info_level == (unsigned int) -1)
1241         error ("unrecognised debug output level \"%s\"", arg);
1242       else if (debug_info_level > 3)
1243         error ("debug output level %s is too high", arg);
1244     }
1245 }
1246
1247 /* Display help for target options.  */
1248 static void
1249 print_target_help (void)
1250 {
1251   unsigned int i;
1252   static bool displayed = false;
1253
1254   /* Avoid double printing for --help --target-help.  */
1255   if (displayed)
1256     return;
1257
1258   displayed = true;
1259   for (i = 0; i < cl_options_count; i++)
1260     if ((cl_options[i].flags & (CL_TARGET | CL_UNDOCUMENTED)) == CL_TARGET)
1261       {
1262         printf (_("\nTarget specific options:\n"));
1263         print_filtered_help (CL_TARGET);
1264         break;
1265       }
1266 }
1267
1268 /* Output --help text.  */
1269 static void
1270 print_help (void)
1271 {
1272   size_t i;
1273   const char *p;
1274
1275   GET_ENVIRONMENT (p, "COLUMNS");
1276   if (p)
1277     {
1278       int value = atoi (p);
1279       if (value > 0)
1280         columns = value;
1281     }
1282
1283   puts (_("The following options are language-independent:\n"));
1284
1285   print_filtered_help (CL_COMMON);
1286   print_param_help ();
1287
1288   for (i = 0; lang_names[i]; i++)
1289     {
1290       printf (_("The %s front end recognizes the following options:\n\n"),
1291               lang_names[i]);
1292       print_filtered_help (1U << i);
1293     }
1294   print_target_help ();
1295 }
1296
1297 /* Print the help for --param.  */
1298 static void
1299 print_param_help (void)
1300 {
1301   size_t i;
1302
1303   puts (_("The --param option recognizes the following as parameters:\n"));
1304
1305   for (i = 0; i < LAST_PARAM; i++)
1306     {
1307       const char *help = compiler_params[i].help;
1308       const char *param = compiler_params[i].option;
1309
1310       if (help == NULL || *help == '\0')
1311         help = undocumented_msg;
1312
1313       /* Get the translation.  */
1314       help = _(help);
1315
1316       wrap_help (help, param, strlen (param));
1317     }
1318
1319   putchar ('\n');
1320 }
1321
1322 /* Print help for a specific front-end, etc.  */
1323 static void
1324 print_filtered_help (unsigned int flag)
1325 {
1326   unsigned int i, len, filter, indent = 0;
1327   bool duplicates = false;
1328   const char *help, *opt, *tab;
1329   static char *printed;
1330
1331   if (flag == CL_COMMON || flag == CL_TARGET)
1332     {
1333       filter = flag;
1334       if (!printed)
1335         printed = xmalloc (cl_options_count);
1336       memset (printed, 0, cl_options_count);
1337     }
1338   else
1339     {
1340       /* Don't print COMMON options twice.  */
1341       filter = flag | CL_COMMON;
1342
1343       for (i = 0; i < cl_options_count; i++)
1344         {
1345           if ((cl_options[i].flags & filter) != flag)
1346             continue;
1347
1348           /* Skip help for internal switches.  */
1349           if (cl_options[i].flags & CL_UNDOCUMENTED)
1350             continue;
1351
1352           /* Skip switches that have already been printed, mark them to be
1353              listed later.  */
1354           if (printed[i])
1355             {
1356               duplicates = true;
1357               indent = print_switch (cl_options[i].opt_text, indent);
1358             }
1359         }
1360
1361       if (duplicates)
1362         {
1363           putchar ('\n');
1364           putchar ('\n');
1365         }
1366     }
1367
1368   for (i = 0; i < cl_options_count; i++)
1369     {
1370       if ((cl_options[i].flags & filter) != flag)
1371         continue;
1372
1373       /* Skip help for internal switches.  */
1374       if (cl_options[i].flags & CL_UNDOCUMENTED)
1375         continue;
1376
1377       /* Skip switches that have already been printed.  */
1378       if (printed[i])
1379         continue;
1380
1381       printed[i] = true;
1382
1383       help = cl_options[i].help;
1384       if (!help)
1385         help = undocumented_msg;
1386
1387       /* Get the translation.  */
1388       help = _(help);
1389
1390       tab = strchr (help, '\t');
1391       if (tab)
1392         {
1393           len = tab - help;
1394           opt = help;
1395           help = tab + 1;
1396         }
1397       else
1398         {
1399           opt = cl_options[i].opt_text;
1400           len = strlen (opt);
1401         }
1402
1403       wrap_help (help, opt, len);
1404     }
1405
1406   putchar ('\n');
1407 }
1408
1409 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1410    word-wrapped HELP in a second column.  */
1411 static unsigned int
1412 print_switch (const char *text, unsigned int indent)
1413 {
1414   unsigned int len = strlen (text) + 1; /* trailing comma */
1415
1416   if (indent)
1417     {
1418       putchar (',');
1419       if (indent + len > columns)
1420         {
1421           putchar ('\n');
1422           putchar (' ');
1423           indent = 1;
1424         }
1425     }
1426   else
1427     putchar (' ');
1428
1429   putchar (' ');
1430   fputs (text, stdout);
1431
1432   return indent + len + 1;
1433 }
1434
1435 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1436    word-wrapped HELP in a second column.  */
1437 static void
1438 wrap_help (const char *help, const char *item, unsigned int item_width)
1439 {
1440   unsigned int col_width = 27;
1441   unsigned int remaining, room, len;
1442
1443   remaining = strlen (help);
1444
1445   do
1446     {
1447       room = columns - 3 - MAX (col_width, item_width);
1448       if (room > columns)
1449         room = 0;
1450       len = remaining;
1451
1452       if (room < len)
1453         {
1454           unsigned int i;
1455
1456           for (i = 0; help[i]; i++)
1457             {
1458               if (i >= room && len != remaining)
1459                 break;
1460               if (help[i] == ' ')
1461                 len = i;
1462               else if ((help[i] == '-' || help[i] == '/')
1463                        && help[i + 1] != ' '
1464                        && i > 0 && ISALPHA (help[i - 1]))
1465                 len = i + 1;
1466             }
1467         }
1468
1469       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1470       item_width = 0;
1471       while (help[len] == ' ')
1472         len++;
1473       help += len;
1474       remaining -= len;
1475     }
1476   while (remaining);
1477 }
1478
1479 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
1480    a simple on-off switch.  */
1481
1482 int
1483 option_enabled (int opt_idx)
1484 {
1485   const struct cl_option *option = &(cl_options[opt_idx]);
1486   if (option->flag_var)
1487     switch (option->var_type)
1488       {
1489       case CLVC_BOOLEAN:
1490         return *(int *) option->flag_var != 0;
1491
1492       case CLVC_EQUAL:
1493         return *(int *) option->flag_var == option->var_value;
1494
1495       case CLVC_BIT_CLEAR:
1496         return (*(int *) option->flag_var & option->var_value) == 0;
1497
1498       case CLVC_BIT_SET:
1499         return (*(int *) option->flag_var & option->var_value) != 0;
1500
1501       case CLVC_STRING:
1502         break;
1503       }
1504   return -1;
1505 }
1506
1507 /* Fill STATE with the current state of option OPTION.  Return true if
1508    there is some state to store.  */
1509
1510 bool
1511 get_option_state (int option, struct cl_option_state *state)
1512 {
1513   if (cl_options[option].flag_var == 0)
1514     return false;
1515
1516   switch (cl_options[option].var_type)
1517     {
1518     case CLVC_BOOLEAN:
1519     case CLVC_EQUAL:
1520       state->data = cl_options[option].flag_var;
1521       state->size = sizeof (int);
1522       break;
1523
1524     case CLVC_BIT_CLEAR:
1525     case CLVC_BIT_SET:
1526       state->ch = option_enabled (option);
1527       state->data = &state->ch;
1528       state->size = 1;
1529       break;
1530
1531     case CLVC_STRING:
1532       state->data = *(const char **) cl_options[option].flag_var;
1533       if (state->data == 0)
1534         state->data = "";
1535       state->size = strlen (state->data) + 1;
1536       break;
1537     }
1538   return true;
1539 }