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