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_sra = 1;
 453       flag_tree_copyrename = 1;
 454       flag_tree_fre = 1;
 455       flag_tree_copy_prop = 1;
 456       flag_tree_sink = 1;
 457       flag_tree_salias = 1;
 458       if (!no_unit_at_a_time_default)
 459         flag_unit_at_a_time = 1;
 460
 461       if (!optimize_size)
 462         {
 463           /* Loop header copying usually increases size of the code.  This used
 464              not to be true, since quite often it is possible to verify that
 465              the condition is satisfied in the first iteration and therefore
 466              to eliminate it.  Jump threading handles these cases now.  */
 467           flag_tree_ch = 1;
 468         }
 469     }
 470
 471   if (optimize >= 2)
 472     {
 473       flag_thread_jumps = 1;
 474       flag_crossjumping = 1;
 475       flag_optimize_sibling_calls = 1;
 476       flag_forward_propagate = 1;
 477       flag_cse_follow_jumps = 1;
 478       flag_gcse = 1;
 479       flag_expensive_optimizations = 1;
 480       flag_ipa_type_escape = 1;
 481       flag_rerun_cse_after_loop = 1;
 482       flag_caller_saves = 1;
 483       flag_peephole2 = 1;
 484 #ifdef INSN_SCHEDULING
 485       flag_schedule_insns = 1;
 486       flag_schedule_insns_after_reload = 1;
 487 #endif
 488       flag_regmove = 1;
 489       flag_strict_aliasing = 1;
 490       flag_delete_null_pointer_checks = 1;
 491       flag_reorder_blocks = 1;
 492       flag_reorder_functions = 1;
 493       flag_tree_store_ccp = 1;
 494       flag_tree_store_copy_prop = 1;
 495       flag_tree_vrp = 1;
 496
 497       if (!optimize_size)
 498         {
 499           /* PRE tends to generate bigger code.  */
 500           flag_tree_pre = 1;
 501         }
 502     }
 503
 504   if (optimize >= 3)
 505     {
 506       flag_inline_functions = 1;
 507       flag_unswitch_loops = 1;
 508       flag_gcse_after_reload = 1;
 509     }
 510
 511   if (optimize < 2 || optimize_size)
 512     {
 513       align_loops = 1;
 514       align_jumps = 1;
 515       align_labels = 1;
 516       align_functions = 1;
 517
 518       /* Don't reorder blocks when optimizing for size because extra
 519          jump insns may be created; also barrier may create extra padding.
 520
 521          More correctly we should have a block reordering mode that tried
 522          to minimize the combined size of all the jumps.  This would more
 523          or less automatically remove extra jumps, but would also try to
 524          use more short jumps instead of long jumps.  */
 525       flag_reorder_blocks = 0;
 526       flag_reorder_blocks_and_partition = 0;
 527     }
 528
 529   if (optimize_size)
 530     {
 531       /* Inlining of very small functions usually reduces total size.  */
 532       set_param_value ("max-inline-insns-single", 5);
 533       set_param_value ("max-inline-insns-auto", 5);
 534       flag_inline_functions = 1;
 535
 536       /* We want to crossjump as much as possible.  */
 537       set_param_value ("min-crossjump-insns", 1);
 538     }
 539
 540   /* Initialize whether `char' is signed.  */
 541   flag_signed_char = DEFAULT_SIGNED_CHAR;
 542   /* Set this to a special "uninitialized" value.  The actual default is set
 543      after target options have been processed.  */
 544   flag_short_enums = 2;
 545
 546   /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
 547      modify it.  */
 548   target_flags = targetm.default_target_flags;
 549
 550   /* Some tagets have ABI-specified unwind tables.  */
 551   flag_unwind_tables = targetm.unwind_tables_default;
 552
 553 #ifdef OPTIMIZATION_OPTIONS
 554   /* Allow default optimizations to be specified on a per-machine basis.  */
 555   OPTIMIZATION_OPTIONS (optimize, optimize_size);
 556 #endif
 557
 558   handle_options (argc, argv, lang_mask);
 559
 560   if (flag_pie)
 561     flag_pic = flag_pie;
 562   if (flag_pic && !flag_pie)
 563     flag_shlib = 1;
 564
 565   if (flag_no_inline == 2)
 566     flag_no_inline = 0;
 567   else
 568     flag_really_no_inline = flag_no_inline;
 569
 570   /* Set flag_no_inline before the post_options () hook.  The C front
 571      ends use it to determine tree inlining defaults.  FIXME: such
 572      code should be lang-independent when all front ends use tree
 573      inlining, in which case it, and this condition, should be moved
 574      to the top of process_options() instead.  */
 575   if (optimize == 0)
 576     {
 577       /* Inlining does not work if not optimizing,
 578          so force it not to be done.  */
 579       flag_no_inline = 1;
 580       warn_inline = 0;
 581
 582       /* The c_decode_option function and decode_option hook set
 583          this to `2' if -Wall is used, so we can avoid giving out
 584          lots of errors for people who don't realize what -Wall does.  */
 585       if (warn_uninitialized == 1)
 586         warning (OPT_Wuninitialized,
 587                  "-Wuninitialized is not supported without -O");
 588     }
 589
 590   if (flag_really_no_inline == 2)
 591     flag_really_no_inline = flag_no_inline;
 592
 593   /* The optimization to partition hot and cold basic blocks into separate
 594      sections of the .o and executable files does not work (currently)
 595      with exception handling.  This is because there is no support for
 596      generating unwind info.  If flag_exceptions is turned on we need to
 597      turn off the partitioning optimization.  */
 598
 599   if (flag_exceptions && flag_reorder_blocks_and_partition)
 600     {
 601       inform
 602             ("-freorder-blocks-and-partition does not work with exceptions");
 603       flag_reorder_blocks_and_partition = 0;
 604       flag_reorder_blocks = 1;
 605     }
 606
 607   /* If user requested unwind info, then turn off the partitioning
 608      optimization.  */
 609
 610   if (flag_unwind_tables && ! targetm.unwind_tables_default
 611       && flag_reorder_blocks_and_partition)
 612     {
 613       inform ("-freorder-blocks-and-partition does not support unwind info");
 614       flag_reorder_blocks_and_partition = 0;
 615       flag_reorder_blocks = 1;
 616     }
 617
 618   /* If the target requested unwind info, then turn off the partitioning
 619      optimization with a different message.  Likewise, if the target does not
 620      support named sections.  */
 621
 622   if (flag_reorder_blocks_and_partition
 623       && (!targetm.have_named_sections
 624           || (flag_unwind_tables && targetm.unwind_tables_default)))
 625     {
 626       inform
 627        ("-freorder-blocks-and-partition does not work on this architecture");
 628       flag_reorder_blocks_and_partition = 0;
 629       flag_reorder_blocks = 1;
 630     }
 631 }
 632
 633 /* Handle target- and language-independent options.  Return zero to
 634    generate an "unknown option" message.  Only options that need
 635    extra handling need to be listed here; if you simply want
 636    VALUE assigned to a variable, it happens automatically.  */
 637
 638 static int
 639 common_handle_option (size_t scode, const char *arg, int value,
 640                       unsigned int lang_mask)
 641 {
 642   enum opt_code code = (enum opt_code) scode;
 643
 644   switch (code)
 645     {
 646     case OPT__help:
 647       print_help ();
 648       exit_after_options = true;
 649       break;
 650
 651     case OPT__param:
 652       handle_param (arg);
 653       break;
 654
 655     case OPT__target_help:
 656       print_target_help ();
 657       exit_after_options = true;
 658       break;
 659
 660     case OPT__version:
 661       print_version (stderr, "");
 662       exit_after_options = true;
 663       break;
 664
 665     case OPT_G:
 666       g_switch_value = value;
 667       g_switch_set = true;
 668       break;
 669
 670     case OPT_O:
 671     case OPT_Os:
 672       /* Currently handled in a prescan.  */
 673       break;
 674
 675     case OPT_W:
 676       /* For backward compatibility, -W is the same as -Wextra.  */
 677       set_Wextra (value);
 678       break;
 679
 680     case OPT_Werror_:
 681       {
 682         char *new_option;
 683         int option_index;
 684         new_option = XNEWVEC (char, strlen (arg) + 2);
 685         new_option[0] = 'W';
 686         strcpy (new_option+1, arg);
 687         option_index = find_opt (new_option, lang_mask);
 688         if (option_index == N_OPTS)
 689           {
 690             error ("-Werror-%s: No option -%s", arg, new_option);
 691           }
 692         else
 693           {
 694             int kind = value ? DK_ERROR : DK_WARNING;
 695             diagnostic_classify_diagnostic (global_dc, option_index, kind);
 696
 697             /* -Werror=foo implies -Wfoo.  */
 698             if (cl_options[option_index].var_type == CLVC_BOOLEAN
 699                 && cl_options[option_index].flag_var
 700                 && kind == DK_ERROR)
 701               *(int *) cl_options[option_index].flag_var = 1;
 702             free (new_option);
 703           }
 704       }
 705       break;
 706
 707     case OPT_Wextra:
 708       set_Wextra (value);
 709       break;
 710
 711     case OPT_Wlarger_than_:
 712       larger_than_size = value;
 713       warn_larger_than = value != -1;
 714       break;
 715
 716     case OPT_Wstrict_aliasing:
 717     case OPT_Wstrict_aliasing_:
 718       warn_strict_aliasing = value;
 719       break;
 720
 721     case OPT_Wunused:
 722       set_Wunused (value);
 723       break;
 724
 725     case OPT_aux_info:
 726     case OPT_aux_info_:
 727       aux_info_file_name = arg;
 728       flag_gen_aux_info = 1;
 729       break;
 730
 731     case OPT_auxbase:
 732       aux_base_name = arg;
 733       break;
 734
 735     case OPT_auxbase_strip:
 736       {
 737         char *tmp = xstrdup (arg);
 738         strip_off_ending (tmp, strlen (tmp));
 739         if (tmp[0])
 740           aux_base_name = tmp;
 741       }
 742       break;
 743
 744     case OPT_d:
 745       decode_d_option (arg);
 746       break;
 747
 748     case OPT_dumpbase:
 749       dump_base_name = arg;
 750       break;
 751
 752     case OPT_falign_functions_:
 753       align_functions = value;
 754       break;
 755
 756     case OPT_falign_jumps_:
 757       align_jumps = value;
 758       break;
 759
 760     case OPT_falign_labels_:
 761       align_labels = value;
 762       break;
 763
 764     case OPT_falign_loops_:
 765       align_loops = value;
 766       break;
 767
 768     case OPT_fbranch_probabilities:
 769       flag_branch_probabilities_set = true;
 770       break;
 771
 772     case OPT_fcall_used_:
 773       fix_register (arg, 0, 1);
 774       break;
 775
 776     case OPT_fcall_saved_:
 777       fix_register (arg, 0, 0);
 778       break;
 779
 780     case OPT_fdiagnostics_show_location_:
 781       if (!strcmp (arg, "once"))
 782         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 783       else if (!strcmp (arg, "every-line"))
 784         diagnostic_prefixing_rule (global_dc)
 785           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
 786       else
 787         return 0;
 788       break;
 789
 790     case OPT_fdiagnostics_show_option:
 791       global_dc->show_option_requested = true;
 792       break;
 793
 794     case OPT_fdump_:
 795       if (!dump_switch_p (arg))
 796         return 0;
 797       break;
 798
 799     case OPT_ffast_math:
 800       set_fast_math_flags (value);
 801       break;
 802
 803     case OPT_ffixed_:
 804       fix_register (arg, 1, 1);
 805       break;
 806
 807     case OPT_finline_limit_:
 808     case OPT_finline_limit_eq:
 809       set_param_value ("max-inline-insns-single", value / 2);
 810       set_param_value ("max-inline-insns-auto", value / 2);
 811       break;
 812
 813     case OPT_fmessage_length_:
 814       pp_set_line_maximum_length (global_dc->printer, value);
 815       break;
 816
 817     case OPT_fpack_struct_:
 818       if (value <= 0 || (value & (value - 1)) || value > 16)
 819         error("structure alignment must be a small power of two, not %d", value);
 820       else
 821         {
 822           initial_max_fld_align = value;
 823           maximum_field_alignment = value * BITS_PER_UNIT;
 824         }
 825       break;
 826
 827     case OPT_fpeel_loops:
 828       flag_peel_loops_set = true;
 829       break;
 830
 831     case OPT_fprofile_arcs:
 832       profile_arc_flag_set = true;
 833       break;
 834
 835     case OPT_fprofile_use:
 836       if (!flag_branch_probabilities_set)
 837         flag_branch_probabilities = value;
 838       if (!flag_profile_values_set)
 839         flag_profile_values = value;
 840       if (!flag_unroll_loops_set)
 841         flag_unroll_loops = value;
 842       if (!flag_peel_loops_set)
 843         flag_peel_loops = value;
 844       if (!flag_tracer_set)
 845         flag_tracer = value;
 846       if (!flag_value_profile_transformations_set)
 847         flag_value_profile_transformations = value;
 848       break;
 849
 850     case OPT_fprofile_generate:
 851       if (!profile_arc_flag_set)
 852         profile_arc_flag = value;
 853       if (!flag_profile_values_set)
 854         flag_profile_values = value;
 855       if (!flag_value_profile_transformations_set)
 856         flag_value_profile_transformations = value;
 857       break;
 858
 859     case OPT_fprofile_values:
 860       flag_profile_values_set = true;
 861       break;
 862
 863     case OPT_fvisibility_:
 864       {
 865         if (!strcmp(arg, "default"))
 866           default_visibility = VISIBILITY_DEFAULT;
 867         else if (!strcmp(arg, "internal"))
 868           default_visibility = VISIBILITY_INTERNAL;
 869         else if (!strcmp(arg, "hidden"))
 870           default_visibility = VISIBILITY_HIDDEN;
 871         else if (!strcmp(arg, "protected"))
 872           default_visibility = VISIBILITY_PROTECTED;
 873         else
 874           error ("unrecognized visibility value \"%s\"", arg);
 875       }
 876       break;
 877
 878     case OPT_fvpt:
 879       flag_value_profile_transformations_set = true;
 880       break;
 881
 882     case OPT_frandom_seed:
 883       /* The real switch is -fno-random-seed.  */
 884       if (value)
 885         return 0;
 886       flag_random_seed = NULL;
 887       break;
 888
 889     case OPT_frandom_seed_:
 890       flag_random_seed = arg;
 891       break;
 892
 893     case OPT_fsched_verbose_:
 894 #ifdef INSN_SCHEDULING
 895       fix_sched_param ("verbose", arg);
 896       break;
 897 #else
 898       return 0;
 899 #endif
 900
 901     case OPT_fsched_stalled_insns_:
 902       flag_sched_stalled_insns = value;
 903       if (flag_sched_stalled_insns == 0)
 904         flag_sched_stalled_insns = -1;
 905       break;
 906
 907     case OPT_fsched_stalled_insns_dep_:
 908       flag_sched_stalled_insns_dep = value;
 909       break;
 910
 911     case OPT_fstack_limit:
 912       /* The real switch is -fno-stack-limit.  */
 913       if (value)
 914         return 0;
 915       stack_limit_rtx = NULL_RTX;
 916       break;
 917
 918     case OPT_fstack_limit_register_:
 919       {
 920         int reg = decode_reg_name (arg);
 921         if (reg < 0)
 922           error ("unrecognized register name \"%s\"", arg);
 923         else
 924           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
 925       }
 926       break;
 927
 928     case OPT_fstack_limit_symbol_:
 929       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
 930       break;
 931
 932     case OPT_ftree_vectorizer_verbose_:
 933       vect_set_verbosity_level (arg);
 934       break;
 935
 936     case OPT_ftls_model_:
 937       if (!strcmp (arg, "global-dynamic"))
 938         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
 939       else if (!strcmp (arg, "local-dynamic"))
 940         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
 941       else if (!strcmp (arg, "initial-exec"))
 942         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
 943       else if (!strcmp (arg, "local-exec"))
 944         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
 945       else
 946         warning (0, "unknown tls-model \"%s\"", arg);
 947       break;
 948
 949     case OPT_ftracer:
 950       flag_tracer_set = true;
 951       break;
 952
 953     case OPT_funroll_loops:
 954       flag_unroll_loops_set = true;
 955       break;
 956
 957     case OPT_g:
 958       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
 959       break;
 960
 961     case OPT_gcoff:
 962       set_debug_level (SDB_DEBUG, false, arg);
 963       break;
 964
 965     case OPT_gdwarf_2:
 966       set_debug_level (DWARF2_DEBUG, false, arg);
 967       break;
 968
 969     case OPT_ggdb:
 970       set_debug_level (NO_DEBUG, 2, arg);
 971       break;
 972
 973     case OPT_gstabs:
 974     case OPT_gstabs_:
 975       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
 976       break;
 977
 978     case OPT_gvms:
 979       set_debug_level (VMS_DEBUG, false, arg);
 980       break;
 981
 982     case OPT_gxcoff:
 983     case OPT_gxcoff_:
 984       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
 985       break;
 986
 987     case OPT_o:
 988       asm_file_name = arg;
 989       break;
 990
 991     case OPT_pedantic_errors:
 992       flag_pedantic_errors = pedantic = 1;
 993       break;
 994
 995     case OPT_fforce_mem:
 996       warning (0, "-f[no-]force-mem is nop and option will be removed in 4.2");
 997       break;
 998
 999     case OPT_floop_optimize:
1000     case OPT_frerun_loop_opt:
1001     case OPT_fstrength_reduce:
1002       /* These are no-ops, preserved for backward compatibility.  */
1003       break;
1004
1005     default:
1006       /* If the flag was handled in a standard way, assume the lack of
1007          processing here is intentional.  */
1008       gcc_assert (cl_options[scode].flag_var);
1009       break;
1010     }
1011
1012   return 1;
1013 }
1014
1015 /* Handle --param NAME=VALUE.  */
1016 static void
1017 handle_param (const char *carg)
1018 {
1019   char *equal, *arg;
1020   int value;
1021
1022   arg = xstrdup (carg);
1023   equal = strchr (arg, '=');
1024   if (!equal)
1025     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1026   else
1027     {
1028       value = integral_argument (equal + 1);
1029       if (value == -1)
1030         error ("invalid --param value %qs", equal + 1);
1031       else
1032         {
1033           *equal = '\0';
1034           set_param_value (arg, value);
1035         }
1036     }
1037
1038   free (arg);
1039 }
1040
1041 /* Handle -W and -Wextra.  */
1042 static void
1043 set_Wextra (int setting)
1044 {
1045   extra_warnings = setting;
1046   warn_unused_value = setting;
1047   warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1048
1049   /* We save the value of warn_uninitialized, since if they put
1050      -Wuninitialized on the command line, we need to generate a
1051      warning about not using it without also specifying -O.  */
1052   if (setting == 0)
1053     warn_uninitialized = 0;
1054   else if (warn_uninitialized != 1)
1055     warn_uninitialized = 2;
1056 }
1057
1058 /* Initialize unused warning flags.  */
1059 void
1060 set_Wunused (int setting)
1061 {
1062   warn_unused_function = setting;
1063   warn_unused_label = setting;
1064   /* Unused function parameter warnings are reported when either
1065      ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1066      Thus, if -Wextra has already been seen, set warn_unused_parameter;
1067      otherwise set maybe_warn_extra_parameter, which will be picked up
1068      by set_Wextra.  */
1069   maybe_warn_unused_parameter = setting;
1070   warn_unused_parameter = (setting && extra_warnings);
1071   warn_unused_variable = setting;
1072   warn_unused_value = setting;
1073 }
1074
1075 /* The following routines are useful in setting all the flags that
1076    -ffast-math and -fno-fast-math imply.  */
1077 void
1078 set_fast_math_flags (int set)
1079 {
1080   flag_trapping_math = !set;
1081   flag_unsafe_math_optimizations = set;
1082   flag_finite_math_only = set;
1083   flag_errno_math = !set;
1084   if (set)
1085     {
1086       flag_signaling_nans = 0;
1087       flag_rounding_math = 0;
1088       flag_cx_limited_range = 1;
1089     }
1090 }
1091
1092 /* Return true iff flags are set as if -ffast-math.  */
1093 bool
1094 fast_math_flags_set_p (void)
1095 {
1096   return (!flag_trapping_math
1097           && flag_unsafe_math_optimizations
1098           && flag_finite_math_only
1099           && !flag_errno_math);
1100 }
1101
1102 /* Handle a debug output -g switch.  EXTENDED is true or false to support
1103    extended output (2 is special and means "-ggdb" was given).  */
1104 static void
1105 set_debug_level (enum debug_info_type type, int extended, const char *arg)
1106 {
1107   static bool type_explicit;
1108
1109   use_gnu_debug_info_extensions = extended;
1110
1111   if (type == NO_DEBUG)
1112     {
1113       if (write_symbols == NO_DEBUG)
1114         {
1115           write_symbols = PREFERRED_DEBUGGING_TYPE;
1116
1117           if (extended == 2)
1118             {
1119 #ifdef DWARF2_DEBUGGING_INFO
1120               write_symbols = DWARF2_DEBUG;
1121 #elif defined DBX_DEBUGGING_INFO
1122               write_symbols = DBX_DEBUG;
1123 #endif
1124             }
1125
1126           if (write_symbols == NO_DEBUG)
1127             warning (0, "target system does not support debug output");
1128         }
1129     }
1130   else
1131     {
1132       /* Does it conflict with an already selected type?  */
1133       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1134         error ("debug format \"%s\" conflicts with prior selection",
1135                debug_type_names[type]);
1136       write_symbols = type;
1137       type_explicit = true;
1138     }
1139
1140   /* A debug flag without a level defaults to level 2.  */
1141   if (*arg == '\0')
1142     {
1143       if (!debug_info_level)
1144         debug_info_level = 2;
1145     }
1146   else
1147     {
1148       debug_info_level = integral_argument (arg);
1149       if (debug_info_level == (unsigned int) -1)
1150         error ("unrecognised debug output level \"%s\"", arg);
1151       else if (debug_info_level > 3)
1152         error ("debug output level %s is too high", arg);
1153     }
1154 }
1155
1156 /* Display help for target options.  */
1157 static void
1158 print_target_help (void)
1159 {
1160   unsigned int i;
1161   static bool displayed = false;
1162
1163   /* Avoid double printing for --help --target-help.  */
1164   if (displayed)
1165     return;
1166
1167   displayed = true;
1168   for (i = 0; i < cl_options_count; i++)
1169     if ((cl_options[i].flags & (CL_TARGET | CL_UNDOCUMENTED)) == CL_TARGET)
1170       {
1171         printf (_("\nTarget specific options:\n"));
1172         print_filtered_help (CL_TARGET);
1173         break;
1174       }
1175 }
1176
1177 /* Output --help text.  */
1178 static void
1179 print_help (void)
1180 {
1181   size_t i;
1182   const char *p;
1183
1184   GET_ENVIRONMENT (p, "COLUMNS");
1185   if (p)
1186     {
1187       int value = atoi (p);
1188       if (value > 0)
1189         columns = value;
1190     }
1191
1192   puts (_("The following options are language-independent:\n"));
1193
1194   print_filtered_help (CL_COMMON);
1195   print_param_help ();
1196
1197   for (i = 0; lang_names[i]; i++)
1198     {
1199       printf (_("The %s front end recognizes the following options:\n\n"),
1200               lang_names[i]);
1201       print_filtered_help (1U << i);
1202     }
1203   print_target_help ();
1204 }
1205
1206 /* Print the help for --param.  */
1207 static void
1208 print_param_help (void)
1209 {
1210   size_t i;
1211
1212   puts (_("The --param option recognizes the following as parameters:\n"));
1213
1214   for (i = 0; i < LAST_PARAM; i++)
1215     {
1216       const char *help = compiler_params[i].help;
1217       const char *param = compiler_params[i].option;
1218
1219       if (help == NULL || *help == '\0')
1220         help = undocumented_msg;
1221
1222       /* Get the translation.  */
1223       help = _(help);
1224
1225       wrap_help (help, param, strlen (param));
1226     }
1227
1228   putchar ('\n');
1229 }
1230
1231 /* Print help for a specific front-end, etc.  */
1232 static void
1233 print_filtered_help (unsigned int flag)
1234 {
1235   unsigned int i, len, filter, indent = 0;
1236   bool duplicates = false;
1237   const char *help, *opt, *tab;
1238   static char *printed;
1239
1240   if (flag == CL_COMMON || flag == CL_TARGET)
1241     {
1242       filter = flag;
1243       if (!printed)
1244         printed = xmalloc (cl_options_count);
1245       memset (printed, 0, cl_options_count);
1246     }
1247   else
1248     {
1249       /* Don't print COMMON options twice.  */
1250       filter = flag | CL_COMMON;
1251
1252       for (i = 0; i < cl_options_count; i++)
1253         {
1254           if ((cl_options[i].flags & filter) != flag)
1255             continue;
1256
1257           /* Skip help for internal switches.  */
1258           if (cl_options[i].flags & CL_UNDOCUMENTED)
1259             continue;
1260
1261           /* Skip switches that have already been printed, mark them to be
1262              listed later.  */
1263           if (printed[i])
1264             {
1265               duplicates = true;
1266               indent = print_switch (cl_options[i].opt_text, indent);
1267             }
1268         }
1269
1270       if (duplicates)
1271         {
1272           putchar ('\n');
1273           putchar ('\n');
1274         }
1275     }
1276
1277   for (i = 0; i < cl_options_count; i++)
1278     {
1279       if ((cl_options[i].flags & filter) != flag)
1280         continue;
1281
1282       /* Skip help for internal switches.  */
1283       if (cl_options[i].flags & CL_UNDOCUMENTED)
1284         continue;
1285
1286       /* Skip switches that have already been printed.  */
1287       if (printed[i])
1288         continue;
1289
1290       printed[i] = true;
1291
1292       help = cl_options[i].help;
1293       if (!help)
1294         help = undocumented_msg;
1295
1296       /* Get the translation.  */
1297       help = _(help);
1298
1299       tab = strchr (help, '\t');
1300       if (tab)
1301         {
1302           len = tab - help;
1303           opt = help;
1304           help = tab + 1;
1305         }
1306       else
1307         {
1308           opt = cl_options[i].opt_text;
1309           len = strlen (opt);
1310         }
1311
1312       wrap_help (help, opt, len);
1313     }
1314
1315   putchar ('\n');
1316 }
1317
1318 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1319    word-wrapped HELP in a second column.  */
1320 static unsigned int
1321 print_switch (const char *text, unsigned int indent)
1322 {
1323   unsigned int len = strlen (text) + 1; /* trailing comma */
1324
1325   if (indent)
1326     {
1327       putchar (',');
1328       if (indent + len > columns)
1329         {
1330           putchar ('\n');
1331           putchar (' ');
1332           indent = 1;
1333         }
1334     }
1335   else
1336     putchar (' ');
1337
1338   putchar (' ');
1339   fputs (text, stdout);
1340
1341   return indent + len + 1;
1342 }
1343
1344 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1345    word-wrapped HELP in a second column.  */
1346 static void
1347 wrap_help (const char *help, const char *item, unsigned int item_width)
1348 {
1349   unsigned int col_width = 27;
1350   unsigned int remaining, room, len;
1351
1352   remaining = strlen (help);
1353
1354   do
1355     {
1356       room = columns - 3 - MAX (col_width, item_width);
1357       if (room > columns)
1358         room = 0;
1359       len = remaining;
1360
1361       if (room < len)
1362         {
1363           unsigned int i;
1364
1365           for (i = 0; help[i]; i++)
1366             {
1367               if (i >= room && len != remaining)
1368                 break;
1369               if (help[i] == ' ')
1370                 len = i;
1371               else if ((help[i] == '-' || help[i] == '/')
1372                        && help[i + 1] != ' '
1373                        && i > 0 && ISALPHA (help[i - 1]))
1374                 len = i + 1;
1375             }
1376         }
1377
1378       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1379       item_width = 0;
1380       while (help[len] == ' ')
1381         len++;
1382       help += len;
1383       remaining -= len;
1384     }
1385   while (remaining);
1386 }
1387
1388 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
1389    a simple on-off switch.  */
1390
1391 int
1392 option_enabled (int opt_idx)
1393 {
1394   const struct cl_option *option = &(cl_options[opt_idx]);
1395   if (option->flag_var)
1396     switch (option->var_type)
1397       {
1398       case CLVC_BOOLEAN:
1399         return *(int *) option->flag_var != 0;
1400
1401       case CLVC_EQUAL:
1402         return *(int *) option->flag_var == option->var_value;
1403
1404       case CLVC_BIT_CLEAR:
1405         return (*(int *) option->flag_var & option->var_value) == 0;
1406
1407       case CLVC_BIT_SET:
1408         return (*(int *) option->flag_var & option->var_value) != 0;
1409
1410       case CLVC_STRING:
1411         break;
1412       }
1413   return -1;
1414 }
1415
1416 /* Fill STATE with the current state of option OPTION.  Return true if
1417    there is some state to store.  */
1418
1419 bool
1420 get_option_state (int option, struct cl_option_state *state)
1421 {
1422   if (cl_options[option].flag_var == 0)
1423     return false;
1424
1425   switch (cl_options[option].var_type)
1426     {
1427     case CLVC_BOOLEAN:
1428     case CLVC_EQUAL:
1429       state->data = cl_options[option].flag_var;
1430       state->size = sizeof (int);
1431       break;
1432
1433     case CLVC_BIT_CLEAR:
1434     case CLVC_BIT_SET:
1435       state->ch = option_enabled (option);
1436       state->data = &state->ch;
1437       state->size = 1;
1438       break;
1439
1440     case CLVC_STRING:
1441       state->data = *(const char **) cl_options[option].flag_var;
1442       if (state->data == 0)
1443         state->data = "";
1444       state->size = strlen (state->data) + 1;
1445       break;
1446     }
1447   return true;
1448 }