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_value = setting;
1046   warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1047
1048   /* We save the value of warn_uninitialized, since if they put
1049      -Wuninitialized on the command line, we need to generate a
1050      warning about not using it without also specifying -O.  */
1051   if (setting == 0)
1052     warn_uninitialized = 0;
1053   else if (warn_uninitialized != 1)
1054     warn_uninitialized = 2;
1055 }
1056
1057 /* Initialize unused warning flags.  */
1058 void
1059 set_Wunused (int setting)
1060 {
1061   warn_unused_function = setting;
1062   warn_unused_label = setting;
1063   /* Unused function parameter warnings are reported when either
1064      ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1065      Thus, if -Wextra has already been seen, set warn_unused_parameter;
1066      otherwise set maybe_warn_extra_parameter, which will be picked up
1067      by set_Wextra.  */
1068   maybe_warn_unused_parameter = setting;
1069   warn_unused_parameter = (setting && extra_warnings);
1070   warn_unused_variable = setting;
1071   warn_unused_value = setting;
1072 }
1073
1074 /* The following routines are useful in setting all the flags that
1075    -ffast-math and -fno-fast-math imply.  */
1076 void
1077 set_fast_math_flags (int set)
1078 {
1079   flag_trapping_math = !set;
1080   flag_unsafe_math_optimizations = set;
1081   flag_finite_math_only = set;
1082   flag_signed_zeros = !set;
1083   flag_errno_math = !set;
1084   if (set)
1085     {
1086       flag_signaling_nans = 0;
1087       flag_rounding_math = 0;
1088       flag_cx_limited_range = 1;
1089     }
1090 }
1091
1092 /* Return true iff flags are set as if -ffast-math.  */
1093 bool
1094 fast_math_flags_set_p (void)
1095 {
1096   return (!flag_trapping_math
1097           && flag_unsafe_math_optimizations
1098           && flag_finite_math_only
1099           && !flag_signed_zeros
1100           && !flag_errno_math);
1101 }
1102
1103 /* Handle a debug output -g switch.  EXTENDED is true or false to support
1104    extended output (2 is special and means "-ggdb" was given).  */
1105 static void
1106 set_debug_level (enum debug_info_type type, int extended, const char *arg)
1107 {
1108   static bool type_explicit;
1109
1110   use_gnu_debug_info_extensions = extended;
1111
1112   if (type == NO_DEBUG)
1113     {
1114       if (write_symbols == NO_DEBUG)
1115         {
1116           write_symbols = PREFERRED_DEBUGGING_TYPE;
1117
1118           if (extended == 2)
1119             {
1120 #ifdef DWARF2_DEBUGGING_INFO
1121               write_symbols = DWARF2_DEBUG;
1122 #elif defined DBX_DEBUGGING_INFO
1123               write_symbols = DBX_DEBUG;
1124 #endif
1125             }
1126
1127           if (write_symbols == NO_DEBUG)
1128             warning (0, "target system does not support debug output");
1129         }
1130     }
1131   else
1132     {
1133       /* Does it conflict with an already selected type?  */
1134       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1135         error ("debug format \"%s\" conflicts with prior selection",
1136                debug_type_names[type]);
1137       write_symbols = type;
1138       type_explicit = true;
1139     }
1140
1141   /* A debug flag without a level defaults to level 2.  */
1142   if (*arg == '\0')
1143     {
1144       if (!debug_info_level)
1145         debug_info_level = 2;
1146     }
1147   else
1148     {
1149       debug_info_level = integral_argument (arg);
1150       if (debug_info_level == (unsigned int) -1)
1151         error ("unrecognised debug output level \"%s\"", arg);
1152       else if (debug_info_level > 3)
1153         error ("debug output level %s is too high", arg);
1154     }
1155 }
1156
1157 /* Display help for target options.  */
1158 static void
1159 print_target_help (void)
1160 {
1161   unsigned int i;
1162   static bool displayed = false;
1163
1164   /* Avoid double printing for --help --target-help.  */
1165   if (displayed)
1166     return;
1167
1168   displayed = true;
1169   for (i = 0; i < cl_options_count; i++)
1170     if ((cl_options[i].flags & (CL_TARGET | CL_UNDOCUMENTED)) == CL_TARGET)
1171       {
1172         printf (_("\nTarget specific options:\n"));
1173         print_filtered_help (CL_TARGET);
1174         break;
1175       }
1176 }
1177
1178 /* Output --help text.  */
1179 static void
1180 print_help (void)
1181 {
1182   size_t i;
1183   const char *p;
1184
1185   GET_ENVIRONMENT (p, "COLUMNS");
1186   if (p)
1187     {
1188       int value = atoi (p);
1189       if (value > 0)
1190         columns = value;
1191     }
1192
1193   puts (_("The following options are language-independent:\n"));
1194
1195   print_filtered_help (CL_COMMON);
1196   print_param_help ();
1197
1198   for (i = 0; lang_names[i]; i++)
1199     {
1200       printf (_("The %s front end recognizes the following options:\n\n"),
1201               lang_names[i]);
1202       print_filtered_help (1U << i);
1203     }
1204   print_target_help ();
1205 }
1206
1207 /* Print the help for --param.  */
1208 static void
1209 print_param_help (void)
1210 {
1211   size_t i;
1212
1213   puts (_("The --param option recognizes the following as parameters:\n"));
1214
1215   for (i = 0; i < LAST_PARAM; i++)
1216     {
1217       const char *help = compiler_params[i].help;
1218       const char *param = compiler_params[i].option;
1219
1220       if (help == NULL || *help == '\0')
1221         help = undocumented_msg;
1222
1223       /* Get the translation.  */
1224       help = _(help);
1225
1226       wrap_help (help, param, strlen (param));
1227     }
1228
1229   putchar ('\n');
1230 }
1231
1232 /* Print help for a specific front-end, etc.  */
1233 static void
1234 print_filtered_help (unsigned int flag)
1235 {
1236   unsigned int i, len, filter, indent = 0;
1237   bool duplicates = false;
1238   const char *help, *opt, *tab;
1239   static char *printed;
1240
1241   if (flag == CL_COMMON || flag == CL_TARGET)
1242     {
1243       filter = flag;
1244       if (!printed)
1245         printed = xmalloc (cl_options_count);
1246       memset (printed, 0, cl_options_count);
1247     }
1248   else
1249     {
1250       /* Don't print COMMON options twice.  */
1251       filter = flag | CL_COMMON;
1252
1253       for (i = 0; i < cl_options_count; i++)
1254         {
1255           if ((cl_options[i].flags & filter) != flag)
1256             continue;
1257
1258           /* Skip help for internal switches.  */
1259           if (cl_options[i].flags & CL_UNDOCUMENTED)
1260             continue;
1261
1262           /* Skip switches that have already been printed, mark them to be
1263              listed later.  */
1264           if (printed[i])
1265             {
1266               duplicates = true;
1267               indent = print_switch (cl_options[i].opt_text, indent);
1268             }
1269         }
1270
1271       if (duplicates)
1272         {
1273           putchar ('\n');
1274           putchar ('\n');
1275         }
1276     }
1277
1278   for (i = 0; i < cl_options_count; i++)
1279     {
1280       if ((cl_options[i].flags & filter) != flag)
1281         continue;
1282
1283       /* Skip help for internal switches.  */
1284       if (cl_options[i].flags & CL_UNDOCUMENTED)
1285         continue;
1286
1287       /* Skip switches that have already been printed.  */
1288       if (printed[i])
1289         continue;
1290
1291       printed[i] = true;
1292
1293       help = cl_options[i].help;
1294       if (!help)
1295         help = undocumented_msg;
1296
1297       /* Get the translation.  */
1298       help = _(help);
1299
1300       tab = strchr (help, '\t');
1301       if (tab)
1302         {
1303           len = tab - help;
1304           opt = help;
1305           help = tab + 1;
1306         }
1307       else
1308         {
1309           opt = cl_options[i].opt_text;
1310           len = strlen (opt);
1311         }
1312
1313       wrap_help (help, opt, len);
1314     }
1315
1316   putchar ('\n');
1317 }
1318
1319 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1320    word-wrapped HELP in a second column.  */
1321 static unsigned int
1322 print_switch (const char *text, unsigned int indent)
1323 {
1324   unsigned int len = strlen (text) + 1; /* trailing comma */
1325
1326   if (indent)
1327     {
1328       putchar (',');
1329       if (indent + len > columns)
1330         {
1331           putchar ('\n');
1332           putchar (' ');
1333           indent = 1;
1334         }
1335     }
1336   else
1337     putchar (' ');
1338
1339   putchar (' ');
1340   fputs (text, stdout);
1341
1342   return indent + len + 1;
1343 }
1344
1345 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1346    word-wrapped HELP in a second column.  */
1347 static void
1348 wrap_help (const char *help, const char *item, unsigned int item_width)
1349 {
1350   unsigned int col_width = 27;
1351   unsigned int remaining, room, len;
1352
1353   remaining = strlen (help);
1354
1355   do
1356     {
1357       room = columns - 3 - MAX (col_width, item_width);
1358       if (room > columns)
1359         room = 0;
1360       len = remaining;
1361
1362       if (room < len)
1363         {
1364           unsigned int i;
1365
1366           for (i = 0; help[i]; i++)
1367             {
1368               if (i >= room && len != remaining)
1369                 break;
1370               if (help[i] == ' ')
1371                 len = i;
1372               else if ((help[i] == '-' || help[i] == '/')
1373                        && help[i + 1] != ' '
1374                        && i > 0 && ISALPHA (help[i - 1]))
1375                 len = i + 1;
1376             }
1377         }
1378
1379       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1380       item_width = 0;
1381       while (help[len] == ' ')
1382         len++;
1383       help += len;
1384       remaining -= len;
1385     }
1386   while (remaining);
1387 }
1388
1389 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
1390    a simple on-off switch.  */
1391
1392 int
1393 option_enabled (int opt_idx)
1394 {
1395   const struct cl_option *option = &(cl_options[opt_idx]);
1396   if (option->flag_var)
1397     switch (option->var_type)
1398       {
1399       case CLVC_BOOLEAN:
1400         return *(int *) option->flag_var != 0;
1401
1402       case CLVC_EQUAL:
1403         return *(int *) option->flag_var == option->var_value;
1404
1405       case CLVC_BIT_CLEAR:
1406         return (*(int *) option->flag_var & option->var_value) == 0;
1407
1408       case CLVC_BIT_SET:
1409         return (*(int *) option->flag_var & option->var_value) != 0;
1410
1411       case CLVC_STRING:
1412         break;
1413       }
1414   return -1;
1415 }
1416
1417 /* Fill STATE with the current state of option OPTION.  Return true if
1418    there is some state to store.  */
1419
1420 bool
1421 get_option_state (int option, struct cl_option_state *state)
1422 {
1423   if (cl_options[option].flag_var == 0)
1424     return false;
1425
1426   switch (cl_options[option].var_type)
1427     {
1428     case CLVC_BOOLEAN:
1429     case CLVC_EQUAL:
1430       state->data = cl_options[option].flag_var;
1431       state->size = sizeof (int);
1432       break;
1433
1434     case CLVC_BIT_CLEAR:
1435     case CLVC_BIT_SET:
1436       state->ch = option_enabled (option);
1437       state->data = &state->ch;
1438       state->size = 1;
1439       break;
1440
1441     case CLVC_STRING:
1442       state->data = *(const char **) cl_options[option].flag_var;
1443       if (state->data == 0)
1444         state->data = "";
1445       state->size = strlen (state->data) + 1;
1446       break;
1447     }
1448   return true;
1449 }