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