gcc/opts.c

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