gcc/opts.c

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