opts.c 38.4 KB
Newer Older
1
/* Command line option handling.
2
   Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
   Contributed by Neil Booth.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING.  If not, write to the Free
kcook's avatar
kcook committed
19 20
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.  */
21 22 23

#include "config.h"
#include "system.h"
neil's avatar
neil committed
24
#include "intl.h"
25 26 27
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
neil's avatar
neil committed
28 29 30
#include "rtl.h"
#include "ggc.h"
#include "output.h"
31 32
#include "langhooks.h"
#include "opts.h"
33 34 35
#include "options.h"
#include "flags.h"
#include "toplev.h"
neil's avatar
neil committed
36
#include "params.h"
neil's avatar
neil committed
37
#include "diagnostic.h"
neil's avatar
neil committed
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

neil's avatar
neil committed
43 44 45 46 47 48 49
/* Value of the -G xx switch, and whether it was passed or not.  */
unsigned HOST_WIDE_INT g_switch_value;
bool g_switch_set;

/* True if we should exit after parsing options.  */
bool exit_after_options;

50 51 52 53 54 55 56 57 58 59 60
/* Print various extra warnings.  -W/-Wextra.  */
bool extra_warnings;

/* True to warn about any objects definitions whose size is larger
   than N bytes.  Also want about function definitions whose returned
   values are larger than N bytes, where N is `larger_than_size'.  */
bool warn_larger_than;
HOST_WIDE_INT larger_than_size;

/* Nonzero means warn about constructs which might not be
   strict-aliasing safe.  */
wilson's avatar
wilson committed
61
int warn_strict_aliasing;
62

neil's avatar
neil committed
63 64 65
/* Hack for cooperation between set_Wunused and set_Wextra.  */
static bool maybe_warn_unused_parameter;

neil's avatar
neil committed
66 67 68 69 70 71 72 73 74 75 76 77 78 79
/* Type(s) of debugging information we are producing (if any).  See
   flags.h for the definitions of the different possible types of
   debugging information.  */
enum debug_info_type write_symbols = NO_DEBUG;

/* Level of debugging information we are producing.  See flags.h for
   the definitions of the different possible levels.  */
enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;

/* Nonzero means use GNU-only extensions in the generated symbolic
   debugging information.  Currently, this only has an effect when
   write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG.  */
bool use_gnu_debug_info_extensions;

giovannibajo's avatar
giovannibajo committed
80 81 82 83 84 85
/* The default visibility for all symbols (unless overridden) */
enum symbol_visibility default_visibility = VISIBILITY_DEFAULT;

/* Global visibility options.  */
struct visibility_flags visibility_options;

neil's avatar
neil committed
86 87 88 89 90 91
/* Columns of --help display.  */
static unsigned int columns = 80;

/* What to print when a switch has no documentation.  */
static const char undocumented_msg[] = N_("This switch lacks documentation");

hubicka's avatar
 
hubicka committed
92 93 94 95 96 97
/* Used for bookkeeping on whether user set these flags so
   -fprofile-use/-fprofile-generate does not use them.  */
static bool profile_arc_flag_set, flag_profile_values_set;
static bool flag_unroll_loops_set, flag_tracer_set;
static bool flag_value_profile_transformations_set;
static bool flag_peel_loops_set, flag_branch_probabilities_set;
hubicka's avatar
 
hubicka committed
98
static bool flag_loop_optimize_set;
hubicka's avatar
 
hubicka committed
99

kazu's avatar
kazu committed
100
/* Input file names.  */
bothner's avatar
 
bothner committed
101 102 103
const char **in_fnames;
unsigned num_in_fnames;

104
static size_t find_opt (const char *, int);
105
static int common_handle_option (size_t scode, const char *arg, int value);
neil's avatar
neil committed
106 107
static void handle_param (const char *);
static void set_Wextra (int);
108
static unsigned int handle_option (const char **argv, unsigned int lang_mask);
109 110 111
static char *write_langs (unsigned int lang_mask);
static void complain_wrong_lang (const char *, const struct cl_option *,
				 unsigned int lang_mask);
112
static void handle_options (unsigned int, const char **, unsigned int);
neil's avatar
neil committed
113
static void wrap_help (const char *help, const char *item, unsigned int);
114
static void print_target_help (void);
neil's avatar
neil committed
115
static void print_help (void);
neil's avatar
neil committed
116
static void print_param_help (void);
117
static void print_filtered_help (unsigned int);
neil's avatar
neil committed
118
static unsigned int print_switch (const char *text, unsigned int indent);
neil's avatar
neil committed
119 120
static void set_debug_level (enum debug_info_type type, int extended,
			     const char *arg);
121 122

/* Perform a binary search to find which option the command-line INPUT
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
   matches.  Returns its index in the option array, and N_OPTS
   (cl_options_count) on failure.

   This routine is quite subtle.  A normal binary search is not good
   enough because some options can be suffixed with an argument, and
   multiple sub-matches can occur, e.g. input of "-pedantic" matching
   the initial substring of "-pedantic-errors".

   A more complicated example is -gstabs.  It should match "-g" with
   an argument of "stabs".  Suppose, however, that the number and list
   of switches are such that the binary search tests "-gen-decls"
   before having tested "-g".  This doesn't match, and as "-gen-decls"
   is less than "-gstabs", it will become the lower bound of the
   binary search range, and "-g" will never be seen.  To resolve this
   issue, opts.sh makes "-gen-decls" point, via the back_chain member,
   to "-g" so that failed searches that end between "-gen-decls" and
   the lexicographically subsequent switch know to go back and see if
   "-g" causes a match (which it does in this example).

   This search is done in such a way that the longest match for the
   front end in question wins.  If there is no match for the current
   front end, the longest match for a different front end is returned
   (or N_OPTS if none) and the caller emits an error message.  */
146
static size_t
147 148
find_opt (const char *input, int lang_mask)
{
149 150
  size_t mn, mx, md, opt_len;
  size_t match_wrong_lang;
151 152 153
  int comp;

  mn = 0;
154
  mx = cl_options_count;
155

156 157 158
  /* Find mn such this lexicographical inequality holds:
     cl_options[mn] <= input < cl_options[mn + 1].  */
  while (mx - mn > 1)
159 160 161
    {
      md = (mn + mx) / 2;
      opt_len = cl_options[md].opt_len;
neil's avatar
neil committed
162
      comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
163 164 165 166

      if (comp < 0)
	mx = md;
      else
167 168 169 170 171 172 173 174 175 176 177 178 179 180
	mn = md;
    }

  /* This is the switch that is the best match but for a different
     front end, or cl_options_count if there is no match at all.  */
  match_wrong_lang = cl_options_count;

  /* Backtrace the chain of possible matches, returning the longest
     one, if any, that fits best.  With current GCC switches, this
     loop executes at most twice.  */
  do
    {
      const struct cl_option *opt = &cl_options[mn];

kraai's avatar
(gcc)  
kraai committed
181 182 183 184
      /* Is the input either an exact match or a prefix that takes a
	 joined argument?  */
      if (!strncmp (input, opt->opt_text + 1, opt->opt_len)
	  && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
185
	{
kraai's avatar
(gcc)  
kraai committed
186 187
	  /* If language is OK, return it.  */
	  if (opt->flags & lang_mask)
188 189 190 191
	    return mn;

	  /* If we haven't remembered a prior match, remember this
	     one.  Any prior match is necessarily better.  */
192
	  if (match_wrong_lang == cl_options_count)
193
	    match_wrong_lang = mn;
194
	}
195 196 197 198

      /* Try the next possibility.  This is cl_options_count if there
	 are no more.  */
      mn = opt->back_chain;
199
    }
200
  while (mn != cl_options_count);
201

202 203
  /* Return the best wrong match, or cl_options_count if none.  */
  return match_wrong_lang;
204 205
}

206
/* If ARG is a non-negative integer made up solely of digits, return its
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
   value, otherwise return -1.  */
static int
integral_argument (const char *arg)
{
  const char *p = arg;

  while (*p && ISDIGIT (*p))
    p++;

  if (*p == '\0')
    return atoi (arg);

  return -1;
}

222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
/* Return a malloced slash-separated list of languages in MASK.  */
static char *
write_langs (unsigned int mask)
{
  unsigned int n = 0, len = 0;
  const char *lang_name;
  char *result;

  for (n = 0; (lang_name = lang_names[n]) != 0; n++)
    if (mask & (1U << n))
      len += strlen (lang_name) + 1;

  result = xmalloc (len);
  len = 0;
  for (n = 0; (lang_name = lang_names[n]) != 0; n++)
    if (mask & (1U << n))
      {
	if (len)
	  result[len++] = '/';
	strcpy (result + len, lang_name);
	len += strlen (lang_name);
      }

  result[len] = 0;

  return result;
}

/* Complain that switch OPT_INDEX does not apply to this front end.  */
static void
complain_wrong_lang (const char *text, const struct cl_option *option,
		     unsigned int lang_mask)
{
  char *ok_langs, *bad_lang;

  ok_langs = write_langs (option->flags);
  bad_lang = write_langs (lang_mask);

  /* Eventually this should become a hard error IMO.  */
261
  warning (0, "command line option \"%s\" is valid for %s but not for %s",
262 263 264 265 266 267 268 269 270
	   text, ok_langs, bad_lang);

  free (ok_langs);
  free (bad_lang);
}

/* Handle the switch beginning at ARGV for the language indicated by
   LANG_MASK.  Returns the number of switches consumed.  */
static unsigned int
271
handle_option (const char **argv, unsigned int lang_mask)
272 273 274 275
{
  size_t opt_index;
  const char *opt, *arg = 0;
  char *dup = 0;
276
  int value = 1;
277
  unsigned int result = 0;
278 279 280 281
  const struct cl_option *option;

  opt = argv[0];

282 283 284
  opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
  if (opt_index == cl_options_count
      && (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm')
285
      && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
286
    {
287
      /* Drop the "no-" from negative switches.  */
288 289 290 291 292 293 294 295
      size_t len = strlen (opt) - 3;

      dup = xmalloc (len + 1);
      dup[0] = '-';
      dup[1] = opt[1];
      memcpy (dup + 2, opt + 5, len - 2 + 1);
      opt = dup;
      value = 0;
296
      opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
297 298
    }

299
  if (opt_index == cl_options_count)
300
    goto done;
301

302
  option = &cl_options[opt_index];
303

304 305 306 307
  /* Reject negative form of switches that don't take negatives as
     unrecognized.  */
  if (!value && (option->flags & CL_REJECT_NEGATIVE))
    goto done;
308

309 310
  /* We've recognized this switch.  */
  result = 1;
311

312 313 314 315 316 317 318 319
  /* Check to see if the option is disabled for this configuration.  */
  if (option->flags & CL_DISABLED)
    {
      error ("command line option %qs"
	     " is not supported by this configuration", opt);
      goto done;
    }

320 321 322 323 324 325 326 327 328 329 330
  /* Sort out any argument the switch takes.  */
  if (option->flags & CL_JOINED)
    {
      /* Have arg point to the original switch.  This is because
	 some code, such as disable_builtin_function, expects its
	 argument to be persistent until the program exits.  */
      arg = argv[0] + cl_options[opt_index].opt_len + 1;
      if (!value)
	arg += strlen ("no-");

      if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
331
	{
332
	  if (option->flags & CL_SEPARATE)
333
	    {
334 335
	      arg = argv[1];
	      result = 2;
336
	    }
337 338 339
	  else
	    /* Missing argument.  */
	    arg = NULL;
340
	}
341 342 343 344 345 346
    }
  else if (option->flags & CL_SEPARATE)
    {
      arg = argv[1];
      result = 2;
    }
347

348 349
  /* Now we've swallowed any potential argument, complain if this
     is a switch for a different front end.  */
350
  if (!(option->flags & (lang_mask | CL_COMMON | CL_TARGET)))
351 352 353 354
    {
      complain_wrong_lang (argv[0], option, lang_mask);
      goto done;
    }
355

356 357
  if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
    {
sayle's avatar
 
sayle committed
358
      if (!lang_hooks.missing_argument (opt, opt_index))
359 360 361
	error ("missing argument to \"%s\"", opt);
      goto done;
    }
362

363 364 365 366 367
  /* If the switch takes an integer, convert it.  */
  if (arg && (option->flags & CL_UINTEGER))
    {
      value = integral_argument (arg);
      if (value == -1)
368
	{
neil's avatar
neil committed
369
	  error ("argument to \"%s\" should be a non-negative integer",
370 371
		 option->opt_text);
	  goto done;
372
	}
373
    }
374

rakdver's avatar
rakdver committed
375
  if (option->flag_var)
376
    switch (option->var_type)
377 378
      {
      case CLVC_BOOLEAN:
379
	*(int *) option->flag_var = value;
380 381 382
	break;

      case CLVC_EQUAL:
383 384 385
	*(int *) option->flag_var = (value
				     ? option->var_value
				     : !option->var_value);
386 387 388 389
	break;

      case CLVC_BIT_CLEAR:
      case CLVC_BIT_SET:
390 391
	if ((value != 0) == (option->var_type == CLVC_BIT_SET))
	  *(int *) option->flag_var |= option->var_value;
392
	else
393
	  *(int *) option->flag_var &= ~option->var_value;
394 395 396
	if (option->flag_var == &target_flags)
	  target_flags_explicit |= option->var_value;
	break;
397 398 399 400

      case CLVC_STRING:
	*(const char **) option->flag_var = arg;
	break;
401
      }
rakdver's avatar
rakdver committed
402
  
403
  if (option->flags & lang_mask)
sayle's avatar
 
sayle committed
404
    if (lang_hooks.handle_option (opt_index, arg, value) == 0)
405
      result = 0;
406

407 408 409
  if (result && (option->flags & CL_COMMON))
    if (common_handle_option (opt_index, arg, value) == 0)
      result = 0;
410

411 412 413 414
  if (result && (option->flags & CL_TARGET))
    if (!targetm.handle_option (opt_index, arg, value))
      result = 0;

415 416 417 418 419
 done:
  if (dup)
    free (dup);
  return result;
}
420

421 422 423 424 425 426 427 428 429
/* Handle FILENAME from the command line.  */
static void
add_input_filename (const char *filename)
{
  num_in_fnames++;
  in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0]));
  in_fnames[num_in_fnames - 1] = filename;
}

430 431 432
/* Decode and handle the vector of command line options.  LANG_MASK
   contains has a single bit set representing the current
   language.  */
neil's avatar
neil committed
433
static void
434
handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
435 436 437 438 439
{
  unsigned int n, i;

  for (i = 1; i < argc; i += n)
    {
440 441 442 443 444
      const char *opt = argv[i];

      /* Interpret "-" or a non-switch as a file name.  */
      if (opt[0] != '-' || opt[1] == '\0')
	{
bothner's avatar
 
bothner committed
445 446
	  if (main_input_filename == NULL)
	    main_input_filename = opt;
bothner's avatar
 
bothner committed
447
	  add_input_filename (opt);
448 449 450 451
	  n = 1;
	  continue;
	}

452 453 454 455 456
      n = handle_option (argv + i, lang_mask);

      if (!n)
	{
	  n = 1;
457
	  error ("unrecognized command line option \"%s\"", opt);
458 459 460 461
	}
    }
}

neil's avatar
neil committed
462 463 464
/* Parse command line options and set default flag values.  Do minimal
   options processing.  */
void
465
decode_options (unsigned int argc, const char **argv)
neil's avatar
neil committed
466
{
467
  unsigned int i, lang_mask;
neil's avatar
neil committed
468 469

  /* Perform language-specific options initialization.  */
sayle's avatar
 
sayle committed
470
  lang_mask = lang_hooks.init_options (argc, argv);
neil's avatar
neil committed
471

472 473
  lang_hooks.initialize_diagnostics (global_dc);

neil's avatar
neil committed
474 475 476 477 478 479 480 481 482 483 484 485
  /* Scan to see what optimization level has been specified.  That will
     determine the default value of many flags.  */
  for (i = 1; i < argc; i++)
    {
      if (!strcmp (argv[i], "-O"))
	{
	  optimize = 1;
	  optimize_size = 0;
	}
      else if (argv[i][0] == '-' && argv[i][1] == 'O')
	{
	  /* Handle -Os, -O2, -O3, -O69, ...  */
486
	  const char *p = &argv[i][2];
neil's avatar
neil committed
487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525

	  if ((p[0] == 's') && (p[1] == 0))
	    {
	      optimize_size = 1;

	      /* Optimizing for size forces optimize to be 2.  */
	      optimize = 2;
	    }
	  else
	    {
	      const int optimize_val = read_integral_parameter (p, p - 2, -1);
	      if (optimize_val != -1)
		{
		  optimize = optimize_val;
		  optimize_size = 0;
		}
	    }
	}
    }

  if (!optimize)
    {
      flag_merge_constants = 0;
    }

  if (optimize >= 1)
    {
      flag_defer_pop = 1;
#ifdef DELAY_SLOTS
      flag_delayed_branch = 1;
#endif
#ifdef CAN_DEBUG_WITHOUT_FP
      flag_omit_frame_pointer = 1;
#endif
      flag_guess_branch_prob = 1;
      flag_cprop_registers = 1;
      flag_loop_optimize = 1;
      flag_if_conversion = 1;
      flag_if_conversion2 = 1;
526 527
      flag_ipa_pure_const = 1;
      flag_ipa_reference = 1;
dnovillo's avatar
 
dnovillo committed
528 529 530 531 532 533 534 535
      flag_tree_ccp = 1;
      flag_tree_dce = 1;
      flag_tree_dom = 1;
      flag_tree_dse = 1;
      flag_tree_ter = 1;
      flag_tree_live_range_split = 1;
      flag_tree_sra = 1;
      flag_tree_copyrename = 1;
dnovillo's avatar
 
dnovillo committed
536
      flag_tree_fre = 1;
dnovillo's avatar
 
dnovillo committed
537
      flag_tree_copy_prop = 1;
538
      flag_tree_sink = 1;
dberlin's avatar
dberlin committed
539
      flag_tree_salias = 1;
hubicka's avatar
 
hubicka committed
540
      flag_unit_at_a_time = 1;
dnovillo's avatar
 
dnovillo committed
541 542 543 544 545 546 547 548 549

      if (!optimize_size)
	{
	  /* Loop header copying usually increases size of the code.  This used
	     not to be true, since quite often it is possible to verify that
	     the condition is satisfied in the first iteration and therefore
	     to eliminate it.  Jump threading handles these cases now.  */
	  flag_tree_ch = 1;
	}
neil's avatar
neil committed
550 551 552 553
    }

  if (optimize >= 2)
    {
steven's avatar
steven committed
554
      flag_thread_jumps = 1;
hubicka's avatar
 
hubicka committed
555
      flag_crossjumping = 1;
neil's avatar
neil committed
556 557 558 559 560
      flag_optimize_sibling_calls = 1;
      flag_cse_follow_jumps = 1;
      flag_cse_skip_blocks = 1;
      flag_gcse = 1;
      flag_expensive_optimizations = 1;
561
      flag_ipa_type_escape = 1;
neil's avatar
neil committed
562 563 564 565 566 567 568 569 570 571 572 573 574 575
      flag_strength_reduce = 1;
      flag_rerun_cse_after_loop = 1;
      flag_rerun_loop_opt = 1;
      flag_caller_saves = 1;
      flag_peephole2 = 1;
#ifdef INSN_SCHEDULING
      flag_schedule_insns = 1;
      flag_schedule_insns_after_reload = 1;
#endif
      flag_regmove = 1;
      flag_strict_aliasing = 1;
      flag_delete_null_pointer_checks = 1;
      flag_reorder_blocks = 1;
      flag_reorder_functions = 1;
dnovillo's avatar
 
dnovillo committed
576 577 578
      flag_tree_store_ccp = 1;
      flag_tree_store_copy_prop = 1;
      flag_tree_vrp = 1;
steven's avatar
steven committed
579 580 581 582 583 584

      if (!optimize_size)
	{
          /* PRE tends to generate bigger code.  */
          flag_tree_pre = 1;
	}
neil's avatar
neil committed
585 586 587 588 589 590
    }

  if (optimize >= 3)
    {
      flag_inline_functions = 1;
      flag_unswitch_loops = 1;
591
      flag_gcse_after_reload = 1;
neil's avatar
neil committed
592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
    }

  if (optimize < 2 || optimize_size)
    {
      align_loops = 1;
      align_jumps = 1;
      align_labels = 1;
      align_functions = 1;

      /* Don't reorder blocks when optimizing for size because extra
	 jump insns may be created; also barrier may create extra padding.

	 More correctly we should have a block reordering mode that tried
	 to minimize the combined size of all the jumps.  This would more
	 or less automatically remove extra jumps, but would also try to
	 use more short jumps instead of long jumps.  */
      flag_reorder_blocks = 0;
609
      flag_reorder_blocks_and_partition = 0;
neil's avatar
neil committed
610 611
    }

612 613 614 615 616 617
  if (optimize_size)
    {
      /* Inlining of very small functions usually reduces total size.  */
      set_param_value ("max-inline-insns-single", 5);
      set_param_value ("max-inline-insns-auto", 5);
      flag_inline_functions = 1;
618 619 620

      /* We want to crossjump as much as possible.  */
      set_param_value ("min-crossjump-insns", 1);
621 622
    }

neil's avatar
neil committed
623 624
  /* Initialize whether `char' is signed.  */
  flag_signed_char = DEFAULT_SIGNED_CHAR;
625 626 627
  /* Set this to a special "uninitialized" value.  The actual default is set
     after target options have been processed.  */
  flag_short_enums = 2;
neil's avatar
neil committed
628 629 630

  /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
     modify it.  */
631
  target_flags = targetm.default_target_flags;
neil's avatar
neil committed
632

633 634
  /* Some tagets have ABI-specified unwind tables.  */
  flag_unwind_tables = targetm.unwind_tables_default;
neil's avatar
neil committed
635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668

#ifdef OPTIMIZATION_OPTIONS
  /* Allow default optimizations to be specified on a per-machine basis.  */
  OPTIMIZATION_OPTIONS (optimize, optimize_size);
#endif

  handle_options (argc, argv, lang_mask);

  if (flag_pie)
    flag_pic = flag_pie;
  if (flag_pic && !flag_pie)
    flag_shlib = 1;

  if (flag_no_inline == 2)
    flag_no_inline = 0;
  else
    flag_really_no_inline = flag_no_inline;

  /* Set flag_no_inline before the post_options () hook.  The C front
     ends use it to determine tree inlining defaults.  FIXME: such
     code should be lang-independent when all front ends use tree
     inlining, in which case it, and this condition, should be moved
     to the top of process_options() instead.  */
  if (optimize == 0)
    {
      /* Inlining does not work if not optimizing,
	 so force it not to be done.  */
      flag_no_inline = 1;
      warn_inline = 0;

      /* The c_decode_option function and decode_option hook set
	 this to `2' if -Wall is used, so we can avoid giving out
	 lots of errors for people who don't realize what -Wall does.  */
      if (warn_uninitialized == 1)
669 670
	warning (OPT_Wuninitialized,
		 "-Wuninitialized is not supported without -O");
neil's avatar
neil committed
671 672 673 674
    }

  if (flag_really_no_inline == 2)
    flag_really_no_inline = flag_no_inline;
675 676 677

  /* The optimization to partition hot and cold basic blocks into separate
     sections of the .o and executable files does not work (currently)
wilson's avatar
wilson committed
678 679
     with exception handling.  This is because there is no support for
     generating unwind info.  If flag_exceptions is turned on we need to
680 681 682 683
     turn off the partitioning optimization.  */

  if (flag_exceptions && flag_reorder_blocks_and_partition)
    {
684
      inform 
685 686 687 688
	    ("-freorder-blocks-and-partition does not work with exceptions");
      flag_reorder_blocks_and_partition = 0;
      flag_reorder_blocks = 1;
    }
689

wilson's avatar
wilson committed
690 691 692 693 694 695 696 697 698 699 700 701 702 703 704
  /* If user requested unwind info, then turn off the partitioning
     optimization.  */

  if (flag_unwind_tables && ! targetm.unwind_tables_default
      && flag_reorder_blocks_and_partition)
    {
      inform ("-freorder-blocks-and-parition does not support unwind info");
      flag_reorder_blocks_and_partition = 0;
      flag_reorder_blocks = 1;
    }

  /* If the target requested unwind info, then turn off the partitioning
     optimization with a different message.  Likewise, if the target does not
     support named sections.  */

705
  if (flag_reorder_blocks_and_partition
wilson's avatar
wilson committed
706 707
      && (!targetm.have_named_sections
	  || (flag_unwind_tables && targetm.unwind_tables_default)))
708 709
    {
      inform 
710
       ("-freorder-blocks-and-partition does not work on this architecture");
711 712 713
      flag_reorder_blocks_and_partition = 0;
      flag_reorder_blocks = 1;
    }
neil's avatar
neil committed
714 715
}

716
/* Handle target- and language-independent options.  Return zero to
rakdver's avatar
rakdver committed
717 718 719 720
   generate an "unknown option" message.  Only options that need
   extra handling need to be listed here; if you simply want
   VALUE assigned to a variable, it happens automatically.  */

721
static int
rakdver's avatar
rakdver committed
722
common_handle_option (size_t scode, const char *arg, int value)
723 724 725 726 727
{
  enum opt_code code = (enum opt_code) scode;

  switch (code)
    {
neil's avatar
neil committed
728
    case OPT__help:
neil's avatar
neil committed
729
      print_help ();
neil's avatar
neil committed
730 731 732
      exit_after_options = true;
      break;

neil's avatar
neil committed
733 734 735 736
    case OPT__param:
      handle_param (arg);
      break;

neil's avatar
neil committed
737
    case OPT__target_help:
738
      print_target_help ();
neil's avatar
neil committed
739 740 741 742 743 744 745 746 747
      exit_after_options = true;
      break;

    case OPT__version:
      print_version (stderr, "");
      exit_after_options = true;
      break;

    case OPT_G:
748
      g_switch_value = value;
neil's avatar
neil committed
749 750 751
      g_switch_set = true;
      break;

neil's avatar
neil committed
752 753 754 755 756 757 758 759 760 761 762 763 764 765
    case OPT_O:
    case OPT_Os:
      /* Currently handled in a prescan.  */
      break;

    case OPT_W:
      /* For backward compatibility, -W is the same as -Wextra.  */
      set_Wextra (value);
      break;

    case OPT_Wextra:
      set_Wextra (value);
      break;

766 767 768 769 770 771
    case OPT_Wlarger_than_:
      larger_than_size = value;
      warn_larger_than = value != -1;
      break;

    case OPT_Wstrict_aliasing:
wilson's avatar
wilson committed
772
    case OPT_Wstrict_aliasing_:
773 774 775
      warn_strict_aliasing = value;
      break;

neil's avatar
neil committed
776 777 778 779
    case OPT_Wunused:
      set_Wunused (value);
      break;

neil's avatar
neil committed
780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806
    case OPT_aux_info:
    case OPT_aux_info_:
      aux_info_file_name = arg;
      flag_gen_aux_info = 1;
      break;

    case OPT_auxbase:
      aux_base_name = arg;
      break;

    case OPT_auxbase_strip:
      {
	char *tmp = xstrdup (arg);
	strip_off_ending (tmp, strlen (tmp));
	if (tmp[0])
	  aux_base_name = tmp;
      }
      break;

    case OPT_d:
      decode_d_option (arg);
      break;

    case OPT_dumpbase:
      dump_base_name = arg;
      break;

807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822
    case OPT_falign_functions_:
      align_functions = value;
      break;

    case OPT_falign_jumps_:
      align_jumps = value;
      break;

    case OPT_falign_labels_:
      align_labels = value;
      break;

    case OPT_falign_loops_:
      align_loops = value;
      break;

neil's avatar
neil committed
823
    case OPT_fbranch_probabilities:
hubicka's avatar
 
hubicka committed
824
      flag_branch_probabilities_set = true;
825 826
      break;

hubicka's avatar
 
hubicka committed
827 828 829 830
    case OPT_floop_optimize:
      flag_loop_optimize_set = true;
      break;

neil's avatar
neil committed
831 832 833 834 835 836 837 838
    case OPT_fcall_used_:
      fix_register (arg, 0, 1);
      break;

    case OPT_fcall_saved_:
      fix_register (arg, 0, 0);
      break;

neil's avatar
neil committed
839 840 841 842 843 844 845 846 847 848
    case OPT_fdiagnostics_show_location_:
      if (!strcmp (arg, "once"))
	diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
      else if (!strcmp (arg, "every-line"))
	diagnostic_prefixing_rule (global_dc)
	  = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
      else
	return 0;
      break;

849 850 851 852
    case OPT_fdiagnostics_show_option:
      global_dc->show_option_requested = true;
      break;

dnovillo's avatar
 
dnovillo committed
853 854 855 856 857
    case OPT_fdump_:
      if (!dump_switch_p (arg))
	return 0;
      break;

neil's avatar
neil committed
858 859 860 861 862 863 864 865
    case OPT_ffast_math:
      set_fast_math_flags (value);
      break;

    case OPT_ffixed_:
      fix_register (arg, 1, 1);
      break;

neil's avatar
neil committed
866 867 868 869 870 871
    case OPT_finline_limit_:
    case OPT_finline_limit_eq:
      set_param_value ("max-inline-insns-single", value / 2);
      set_param_value ("max-inline-insns-auto", value / 2);
      break;

neil's avatar
neil committed
872
    case OPT_fmessage_length_:
873
      pp_set_line_maximum_length (global_dc->printer, value);
neil's avatar
neil committed
874 875
      break;

rth's avatar
rth committed
876 877 878 879 880 881 882 883 884 885
    case OPT_fpack_struct_:
      if (value <= 0 || (value & (value - 1)) || value > 16)
	error("structure alignment must be a small power of two, not %d", value);
      else
	{
	  initial_max_fld_align = value;
	  maximum_field_alignment = value * BITS_PER_UNIT;
	}
      break;

neil's avatar
neil committed
886
    case OPT_fpeel_loops:
hubicka's avatar
 
hubicka committed
887
      flag_peel_loops_set = true;
neil's avatar
neil committed
888 889 890
      break;

    case OPT_fprofile_arcs:
hubicka's avatar
 
hubicka committed
891
      profile_arc_flag_set = true;
neil's avatar
neil committed
892 893
      break;

hubicka's avatar
 
hubicka committed
894 895 896 897 898 899 900 901 902 903 904 905 906
    case OPT_fprofile_use:
      if (!flag_branch_probabilities_set)
        flag_branch_probabilities = value;
      if (!flag_profile_values_set)
        flag_profile_values = value;
      if (!flag_unroll_loops_set)
        flag_unroll_loops = value;
      if (!flag_peel_loops_set)
        flag_peel_loops = value;
      if (!flag_tracer_set)
        flag_tracer = value;
      if (!flag_value_profile_transformations_set)
        flag_value_profile_transformations = value;
hubicka's avatar
 
hubicka committed
907 908 909
      /* Old loop optimizer is incompatible with tree profiling.  */
      if (!flag_loop_optimize_set)
	flag_loop_optimize = 0;
hubicka's avatar
 
hubicka committed
910 911 912 913 914 915 916 917 918 919 920
      break;

    case OPT_fprofile_generate:
      if (!profile_arc_flag_set)
        profile_arc_flag = value;
      if (!flag_profile_values_set)
        flag_profile_values = value;
      if (!flag_value_profile_transformations_set)
        flag_value_profile_transformations = value;
      break;

921
    case OPT_fprofile_values:
hubicka's avatar
 
hubicka committed
922
      flag_profile_values_set = true;
923 924
      break;

giovannibajo's avatar
giovannibajo committed
925 926 927 928 929 930 931 932 933 934 935
    case OPT_fvisibility_:
      {
        if (!strcmp(arg, "default"))
          default_visibility = VISIBILITY_DEFAULT;
        else if (!strcmp(arg, "internal"))
          default_visibility = VISIBILITY_INTERNAL;
        else if (!strcmp(arg, "hidden"))
          default_visibility = VISIBILITY_HIDDEN;
        else if (!strcmp(arg, "protected"))
          default_visibility = VISIBILITY_PROTECTED;
        else
936
          error ("unrecognized visibility value \"%s\"", arg);
giovannibajo's avatar
giovannibajo committed
937 938 939
      }
      break;

940
    case OPT_fvpt:
941 942 943
      flag_value_profile_transformations_set = true;
      break;

neil's avatar
neil committed
944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962
    case OPT_frandom_seed:
      /* The real switch is -fno-random-seed.  */
      if (value)
	return 0;
      flag_random_seed = NULL;
      break;

    case OPT_frandom_seed_:
      flag_random_seed = arg;
      break;

    case OPT_fsched_verbose_:
#ifdef INSN_SCHEDULING
      fix_sched_param ("verbose", arg);
      break;
#else
      return 0;
#endif

963 964 965 966 967 968 969 970 971
    case OPT_fsched_stalled_insns_:
      flag_sched_stalled_insns = value;
      if (flag_sched_stalled_insns == 0)
	flag_sched_stalled_insns = -1;
      break;

    case OPT_fsched_stalled_insns_dep_:
      flag_sched_stalled_insns_dep = value;
      break;
neil's avatar
neil committed
972

neil's avatar
neil committed
973 974 975 976 977 978 979
    case OPT_fstack_limit:
      /* The real switch is -fno-stack-limit.  */
      if (value)
	return 0;
      stack_limit_rtx = NULL_RTX;
      break;

neil's avatar
neil committed
980 981 982 983 984 985 986 987 988 989 990 991 992 993
    case OPT_fstack_limit_register_:
      {
	int reg = decode_reg_name (arg);
	if (reg < 0)
	  error ("unrecognized register name \"%s\"", arg);
	else
	  stack_limit_rtx = gen_rtx_REG (Pmode, reg);
      }
      break;

    case OPT_fstack_limit_symbol_:
      stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
      break;

994 995 996 997
    case OPT_ftree_vectorizer_verbose_:
      vect_set_verbosity_level (arg);
      break;

neil's avatar
neil committed
998 999 1000 1001 1002 1003 1004 1005 1006 1007
    case OPT_ftls_model_:
      if (!strcmp (arg, "global-dynamic"))
	flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
      else if (!strcmp (arg, "local-dynamic"))
	flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
      else if (!strcmp (arg, "initial-exec"))
	flag_tls_default = TLS_MODEL_INITIAL_EXEC;
      else if (!strcmp (arg, "local-exec"))
	flag_tls_default = TLS_MODEL_LOCAL_EXEC;
      else
1008
	warning (0, "unknown tls-model \"%s\"", arg);
neil's avatar
neil committed
1009 1010
      break;

neil's avatar
neil committed
1011
    case OPT_ftracer:
hubicka's avatar
 
hubicka committed
1012
      flag_tracer_set = true;
dnovillo's avatar
 
dnovillo committed
1013 1014
      break;

neil's avatar
neil committed
1015
    case OPT_funroll_loops:
hubicka's avatar
 
hubicka committed
1016
      flag_unroll_loops_set = true;
neil's avatar
neil committed
1017 1018
      break;

1019
    case OPT_g:
neil's avatar
neil committed
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046
      set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
      break;

    case OPT_gcoff:
      set_debug_level (SDB_DEBUG, false, arg);
      break;

    case OPT_gdwarf_2:
      set_debug_level (DWARF2_DEBUG, false, arg);
      break;

    case OPT_ggdb:
      set_debug_level (NO_DEBUG, 2, arg);
      break;

    case OPT_gstabs:
    case OPT_gstabs_:
      set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
      break;

    case OPT_gvms:
      set_debug_level (VMS_DEBUG, false, arg);
      break;

    case OPT_gxcoff:
    case OPT_gxcoff_:
      set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
1047 1048
      break;

neil's avatar
neil committed
1049 1050 1051 1052 1053 1054 1055 1056
    case OPT_o:
      asm_file_name = arg;
      break;

    case OPT_pedantic_errors:
      flag_pedantic_errors = pedantic = 1;
      break;

fjahanian's avatar
fjahanian committed
1057 1058 1059 1060
    case OPT_fforce_mem:
      warning (0, "-f[no-]force-mem is nop and option will be removed in 4.2");
      break;

rakdver's avatar
rakdver committed
1061 1062 1063
    default:
      /* If the flag was handled in a standard way, assume the lack of
	 processing here is intentional.  */
1064 1065
      gcc_assert (cl_options[scode].flag_var);
      break;
1066 1067 1068 1069
    }

  return 1;
}
neil's avatar
neil committed
1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085

/* Handle --param NAME=VALUE.  */
static void
handle_param (const char *carg)
{
  char *equal, *arg;
  int value;

  arg = xstrdup (carg);
  equal = strchr (arg, '=');
  if (!equal)
    error ("%s: --param arguments should be of the form NAME=VALUE", arg);
  else
    {
      value = integral_argument (equal + 1);
      if (value == -1)
1086
	error ("invalid --param value %qs", equal + 1);
neil's avatar
neil committed
1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129
      else
	{
	  *equal = '\0';
	  set_param_value (arg, value);
	}
    }

  free (arg);
}

/* Handle -W and -Wextra.  */
static void
set_Wextra (int setting)
{
  extra_warnings = setting;
  warn_unused_value = setting;
  warn_unused_parameter = (setting && maybe_warn_unused_parameter);

  /* We save the value of warn_uninitialized, since if they put
     -Wuninitialized on the command line, we need to generate a
     warning about not using it without also specifying -O.  */
  if (setting == 0)
    warn_uninitialized = 0;
  else if (warn_uninitialized != 1)
    warn_uninitialized = 2;
}

/* Initialize unused warning flags.  */
void
set_Wunused (int setting)
{
  warn_unused_function = setting;
  warn_unused_label = setting;
  /* Unused function parameter warnings are reported when either
     ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
     Thus, if -Wextra has already been seen, set warn_unused_parameter;
     otherwise set maybe_warn_extra_parameter, which will be picked up
     by set_Wextra.  */
  maybe_warn_unused_parameter = setting;
  warn_unused_parameter = (setting && extra_warnings);
  warn_unused_variable = setting;
  warn_unused_value = setting;
}
neil's avatar
neil committed
1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140

/* The following routines are useful in setting all the flags that
   -ffast-math and -fno-fast-math imply.  */
void
set_fast_math_flags (int set)
{
  flag_trapping_math = !set;
  flag_unsafe_math_optimizations = set;
  flag_finite_math_only = set;
  flag_errno_math = !set;
  if (set)
sayle's avatar
 
sayle committed
1141 1142 1143
    {
      flag_signaling_nans = 0;
      flag_rounding_math = 0;
rth's avatar
rth committed
1144
      flag_cx_limited_range = 1;
sayle's avatar
 
sayle committed
1145
    }
neil's avatar
neil committed
1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
}

/* Return true iff flags are set as if -ffast-math.  */
bool
fast_math_flags_set_p (void)
{
  return (!flag_trapping_math
	  && flag_unsafe_math_optimizations
	  && flag_finite_math_only
	  && !flag_errno_math);
}
neil's avatar
neil committed
1157

neil's avatar
neil committed
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182
/* Handle a debug output -g switch.  EXTENDED is true or false to support
   extended output (2 is special and means "-ggdb" was given).  */
static void
set_debug_level (enum debug_info_type type, int extended, const char *arg)
{
  static bool type_explicit;

  use_gnu_debug_info_extensions = extended;

  if (type == NO_DEBUG)
    {
      if (write_symbols == NO_DEBUG)
	{
	  write_symbols = PREFERRED_DEBUGGING_TYPE;

	  if (extended == 2)
	    {
#ifdef DWARF2_DEBUGGING_INFO
	      write_symbols = DWARF2_DEBUG;
#elif defined DBX_DEBUGGING_INFO
	      write_symbols = DBX_DEBUG;
#endif
	    }

	  if (write_symbols == NO_DEBUG)
1183
	    warning (0, "target system does not support debug output");
neil's avatar
neil committed
1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211
	}
    }
  else
    {
      /* Does it conflict with an already selected type?  */
      if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
	error ("debug format \"%s\" conflicts with prior selection",
	       debug_type_names[type]);
      write_symbols = type;
      type_explicit = true;
    }

  /* A debug flag without a level defaults to level 2.  */
  if (*arg == '\0')
    {
      if (!debug_info_level)
	debug_info_level = 2;
    }
  else
    {
      debug_info_level = integral_argument (arg);
      if (debug_info_level == (unsigned int) -1)
	error ("unrecognised debug output level \"%s\"", arg);
      else if (debug_info_level > 3)
	error ("debug output level %s is too high", arg);
    }
}

1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
/* Display help for target options.  */
static void
print_target_help (void)
{
  unsigned int i;
  static bool displayed = false;

  /* Avoid double printing for --help --target-help.  */
  if (displayed)
    return;

  displayed = true;
  for (i = 0; i < cl_options_count; i++)
    if ((cl_options[i].flags & (CL_TARGET | CL_UNDOCUMENTED)) == CL_TARGET)
      {
	printf (_("\nTarget specific options:\n"));
	print_filtered_help (CL_TARGET);
	break;
      }
}

neil's avatar
neil committed
1233 1234 1235
/* Output --help text.  */
static void
print_help (void)
neil's avatar
neil committed
1236 1237
{
  size_t i;
neil's avatar
neil committed
1238 1239 1240 1241 1242 1243 1244 1245 1246
  const char *p;

  GET_ENVIRONMENT (p, "COLUMNS");
  if (p)
    {
      int value = atoi (p);
      if (value > 0)
	columns = value;
    }
neil's avatar
neil committed
1247 1248 1249 1250

  puts (_("The following options are language-independent:\n"));

  print_filtered_help (CL_COMMON);
neil's avatar
neil committed
1251
  print_param_help ();
neil's avatar
neil committed
1252 1253 1254

  for (i = 0; lang_names[i]; i++)
    {
neil's avatar
neil committed
1255
      printf (_("The %s front end recognizes the following options:\n\n"),
neil's avatar
neil committed
1256 1257 1258
	      lang_names[i]);
      print_filtered_help (1U << i);
    }
1259
  print_target_help ();
neil's avatar
neil committed
1260 1261
}

neil's avatar
neil committed
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286
/* Print the help for --param.  */
static void
print_param_help (void)
{
  size_t i;

  puts (_("The --param option recognizes the following as parameters:\n"));

  for (i = 0; i < LAST_PARAM; i++)
    {
      const char *help = compiler_params[i].help;
      const char *param = compiler_params[i].option;

      if (help == NULL || *help == '\0')
	help = undocumented_msg;

      /* Get the translation.  */
      help = _(help);

      wrap_help (help, param, strlen (param));
    }

  putchar ('\n');
}

neil's avatar
neil committed
1287
/* Print help for a specific front-end, etc.  */
1288
static void
neil's avatar
neil committed
1289
print_filtered_help (unsigned int flag)
neil's avatar
neil committed
1290
{
neil's avatar
neil committed
1291 1292 1293 1294 1295
  unsigned int i, len, filter, indent = 0;
  bool duplicates = false;
  const char *help, *opt, *tab;
  static char *printed;

1296
  if (flag == CL_COMMON || flag == CL_TARGET)
neil's avatar
neil committed
1297 1298 1299 1300 1301 1302 1303 1304 1305 1306
    {
      filter = flag;
      if (!printed)
	printed = xmalloc (cl_options_count);
      memset (printed, 0, cl_options_count);
    }
  else
    {
      /* Don't print COMMON options twice.  */
      filter = flag | CL_COMMON;
neil's avatar
neil committed
1307

neil's avatar
neil committed
1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331
      for (i = 0; i < cl_options_count; i++)
	{
	  if ((cl_options[i].flags & filter) != flag)
	    continue;

	  /* Skip help for internal switches.  */
	  if (cl_options[i].flags & CL_UNDOCUMENTED)
	    continue;

	  /* Skip switches that have already been printed, mark them to be
	     listed later.  */
	  if (printed[i])
	    {
	      duplicates = true;
	      indent = print_switch (cl_options[i].opt_text, indent);
	    }
	}

      if (duplicates)
	{
	  putchar ('\n');
	  putchar ('\n');
	}
    }
neil's avatar
neil committed
1332 1333 1334

  for (i = 0; i < cl_options_count; i++)
    {
neil's avatar
neil committed
1335 1336 1337
      if ((cl_options[i].flags & filter) != flag)
	continue;

1338 1339 1340 1341
      /* Skip help for internal switches.  */
      if (cl_options[i].flags & CL_UNDOCUMENTED)
	continue;

neil's avatar
neil committed
1342 1343 1344 1345 1346 1347
      /* Skip switches that have already been printed.  */
      if (printed[i])
	continue;

      printed[i] = true;

neil's avatar
neil committed
1348
      help = cl_options[i].help;
neil's avatar
neil committed
1349
      if (!help)
neil's avatar
neil committed
1350
	help = undocumented_msg;
neil's avatar
neil committed
1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369

      /* Get the translation.  */
      help = _(help);

      tab = strchr (help, '\t');
      if (tab)
	{
	  len = tab - help;
	  opt = help;
	  help = tab + 1;
	}
      else
	{
	  opt = cl_options[i].opt_text;
	  len = strlen (opt);
	}

      wrap_help (help, opt, len);
    }
neil's avatar
neil committed
1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397

  putchar ('\n');
}

/* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
   word-wrapped HELP in a second column.  */
static unsigned int
print_switch (const char *text, unsigned int indent)
{
  unsigned int len = strlen (text) + 1; /* trailing comma */

  if (indent)
    {
      putchar (',');
      if (indent + len > columns)
	{
	  putchar ('\n');
	  putchar (' ');
	  indent = 1;
	}
    }
  else
    putchar (' ');

  putchar (' ');
  fputs (text, stdout);

  return indent + len + 1;
neil's avatar
neil committed
1398 1399 1400 1401 1402
}

/* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
   word-wrapped HELP in a second column.  */
static void
neil's avatar
neil committed
1403
wrap_help (const char *help, const char *item, unsigned int item_width)
neil's avatar
neil committed
1404
{
neil's avatar
neil committed
1405
  unsigned int col_width = 27;
1406
  unsigned int remaining, room, len;
neil's avatar
neil committed
1407 1408 1409 1410 1411 1412

  remaining = strlen (help);

  do
    {
      room = columns - 3 - MAX (col_width, item_width);
neil's avatar
neil committed
1413 1414
      if (room > columns)
	room = 0;
neil's avatar
neil committed
1415 1416 1417 1418
      len = remaining;

      if (room < len)
	{
1419
	  unsigned int i;
neil's avatar
neil committed
1420 1421 1422 1423 1424 1425 1426

	  for (i = 0; help[i]; i++)
	    {
	      if (i >= room && len != remaining)
		break;
	      if (help[i] == ' ')
		len = i;
neil's avatar
neil committed
1427 1428
	      else if ((help[i] == '-' || help[i] == '/')
		       && help[i + 1] != ' '
1429
		       && i > 0 && ISALPHA (help[i - 1]))
neil's avatar
neil committed
1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442
		len = i + 1;
	    }
	}

      printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
      item_width = 0;
      while (help[len] == ' ')
	len++;
      help += len;
      remaining -= len;
    }
  while (remaining);
}
1443 1444 1445 1446 1447

/* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
   a simple on-off switch.  */

int
1448
option_enabled (int opt_idx)
1449
{
1450
  const struct cl_option *option = &(cl_options[opt_idx]);
1451
  if (option->flag_var)
1452
    switch (option->var_type)
1453 1454
      {
      case CLVC_BOOLEAN:
1455
	return *(int *) option->flag_var != 0;
1456 1457

      case CLVC_EQUAL:
1458
	return *(int *) option->flag_var == option->var_value;
1459 1460

      case CLVC_BIT_CLEAR:
1461
	return (*(int *) option->flag_var & option->var_value) == 0;
1462 1463

      case CLVC_BIT_SET:
1464 1465 1466 1467
	return (*(int *) option->flag_var & option->var_value) != 0;

      case CLVC_STRING:
	break;
1468 1469 1470
      }
  return -1;
}
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504

/* Fill STATE with the current state of option OPTION.  Return true if
   there is some state to store.  */

bool
get_option_state (int option, struct cl_option_state *state)
{
  if (cl_options[option].flag_var == 0)
    return false;

  switch (cl_options[option].var_type)
    {
    case CLVC_BOOLEAN:
    case CLVC_EQUAL:
      state->data = cl_options[option].flag_var;
      state->size = sizeof (int);
      break;

    case CLVC_BIT_CLEAR:
    case CLVC_BIT_SET:
      state->ch = option_enabled (option);
      state->data = &state->ch;
      state->size = 1;
      break;

    case CLVC_STRING:
      state->data = *(const char **) cl_options[option].flag_var;
      if (state->data == 0)
	state->data = "";
      state->size = strlen (state->data) + 1;
      break;
    }
  return true;
}