gcc/opts.c

   1 /* Command line option handling.
   2    Copyright (C) 2002, 2003 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, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, 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
  41 /* Value of the -G xx switch, and whether it was passed or not.  */
  42 unsigned HOST_WIDE_INT g_switch_value;
  43 bool g_switch_set;
  44
  45 /* True if we should exit after parsing options.  */
  46 bool exit_after_options;
  47
  48 /* If -version.  */
  49 bool version_flag;
  50
  51 /* Print various extra warnings.  -W/-Wextra.  */
  52 bool extra_warnings;
  53
  54 /* Don't print warning messages.  -w.  */
  55 bool inhibit_warnings;
  56
  57 /* Treat warnings as errors.  -Werror.  */
  58 bool warnings_are_errors;
  59
  60 /* Warn if a function returns an aggregate, since there are often
  61    incompatible calling conventions for doing this.  */
  62 bool warn_aggregate_return;
  63
  64 /* Nonzero means warn about pointer casts that increase the required
  65    alignment of the target type (and might therefore lead to a crash
  66    due to a misaligned access).  */
  67 bool warn_cast_align;
  68
  69 /* Nonzero means warn about uses of __attribute__((deprecated))
  70    declarations.  */
  71 bool warn_deprecated_decl = true;
  72
  73 /* Warn when an optimization pass is disabled.  */
  74 bool warn_disabled_optimization;
  75
  76 /* Nonzero means warn if inline function is too large.  */
  77 bool warn_inline;
  78
  79 /* True to warn about any objects definitions whose size is larger
  80    than N bytes.  Also want about function definitions whose returned
  81    values are larger than N bytes, where N is `larger_than_size'.  */
  82 bool warn_larger_than;
  83 HOST_WIDE_INT larger_than_size;
  84
  85 /* Warn about functions which might be candidates for attribute noreturn.  */
  86 bool warn_missing_noreturn;
  87
  88 /* True to warn about code which is never reached.  */
  89 bool warn_notreached;
  90
  91 /* Warn if packed attribute on struct is unnecessary and inefficient.  */
  92 bool warn_packed;
  93
  94 /* Warn when gcc pads a structure to an alignment boundary.  */
  95 bool warn_padded;
  96
  97 /* True means warn about all declarations which shadow others.  */
  98 bool warn_shadow;
  99
 100 /* Nonzero means warn about constructs which might not be
 101    strict-aliasing safe.  */
 102 bool warn_strict_aliasing;
 103
 104 /* True to warn if a switch on an enum, that does not have a default
 105    case, fails to have a case for every enum value.  */
 106 bool warn_switch;
 107
 108 /* Warn if a switch does not have a default case.  */
 109 bool warn_switch_default;
 110
 111 /* Warn if a switch on an enum fails to have a case for every enum
 112    value (regardless of the presence or otherwise of a default case).  */
 113 bool warn_switch_enum;
 114
 115 /* Don't suppress warnings from system headers.  -Wsystem-headers.  */
 116 bool warn_system_headers;
 117
 118 /* True to warn about variables used before they are initialized.  */
 119 int warn_uninitialized;
 120
 121 /* True to warn about unused variables, functions et.al.  */
 122 bool warn_unused_function;
 123 bool warn_unused_label;
 124 bool warn_unused_parameter;
 125 bool warn_unused_variable;
 126 bool warn_unused_value;
 127
 128 /* Hack for cooperation between set_Wunused and set_Wextra.  */
 129 static bool maybe_warn_unused_parameter;
 130
 131 static size_t find_opt (const char *, int);
 132 static int common_handle_option (size_t scode, const char *arg, int value);
 133 static void handle_param (const char *);
 134 static void set_Wextra (int);
 135 static unsigned int handle_option (const char **argv, unsigned int lang_mask);
 136 static char *write_langs (unsigned int lang_mask);
 137 static void complain_wrong_lang (const char *, const struct cl_option *,
 138                                  unsigned int lang_mask);
 139 static void handle_options (unsigned int, const char **, unsigned int);
 140 static void wrap_help (const char *help, const char *item, int item_width);
 141 static void print_help (void);
 142
 143 /* Perform a binary search to find which option the command-line INPUT
 144    matches.  Returns its index in the option array, and N_OPTS
 145    (cl_options_count) on failure.
 146
 147    This routine is quite subtle.  A normal binary search is not good
 148    enough because some options can be suffixed with an argument, and
 149    multiple sub-matches can occur, e.g. input of "-pedantic" matching
 150    the initial substring of "-pedantic-errors".
 151
 152    A more complicated example is -gstabs.  It should match "-g" with
 153    an argument of "stabs".  Suppose, however, that the number and list
 154    of switches are such that the binary search tests "-gen-decls"
 155    before having tested "-g".  This doesn't match, and as "-gen-decls"
 156    is less than "-gstabs", it will become the lower bound of the
 157    binary search range, and "-g" will never be seen.  To resolve this
 158    issue, opts.sh makes "-gen-decls" point, via the back_chain member,
 159    to "-g" so that failed searches that end between "-gen-decls" and
 160    the lexicographically subsequent switch know to go back and see if
 161    "-g" causes a match (which it does in this example).
 162
 163    This search is done in such a way that the longest match for the
 164    front end in question wins.  If there is no match for the current
 165    front end, the longest match for a different front end is returned
 166    (or N_OPTS if none) and the caller emits an error message.  */
 167 static size_t
 168 find_opt (const char *input, int lang_mask)
 169 {
 170   size_t mn, mx, md, opt_len;
 171   size_t match_wrong_lang;
 172   int comp;
 173
 174   mn = 0;
 175   mx = cl_options_count;
 176
 177   /* Find mn such this lexicographical inequality holds:
 178      cl_options[mn] <= input < cl_options[mn + 1].  */
 179   while (mx - mn > 1)
 180     {
 181       md = (mn + mx) / 2;
 182       opt_len = cl_options[md].opt_len;
 183       comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
 184
 185       if (comp < 0)
 186         mx = md;
 187       else
 188         mn = md;
 189     }
 190
 191   /* This is the switch that is the best match but for a different
 192      front end, or cl_options_count if there is no match at all.  */
 193   match_wrong_lang = cl_options_count;
 194
 195   /* Backtrace the chain of possible matches, returning the longest
 196      one, if any, that fits best.  With current GCC switches, this
 197      loop executes at most twice.  */
 198   do
 199     {
 200       const struct cl_option *opt = &cl_options[mn];
 201
 202       /* Is this switch a prefix of the input?  */
 203       if (!strncmp (input, opt->opt_text + 1, opt->opt_len))
 204         {
 205           /* If language is OK, and the match is exact or the switch
 206              takes a joined argument, return it.  */
 207           if ((opt->flags & lang_mask)
 208               && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
 209             return mn;
 210
 211           /* If we haven't remembered a prior match, remember this
 212              one.  Any prior match is necessarily better.  */
 213           if (match_wrong_lang == cl_options_count)
 214             match_wrong_lang = mn;
 215         }
 216
 217       /* Try the next possibility.  This is cl_options_count if there
 218          are no more.  */
 219       mn = opt->back_chain;
 220     }
 221   while (mn != cl_options_count);
 222
 223   /* Return the best wrong match, or cl_options_count if none.  */
 224   return match_wrong_lang;
 225 }
 226
 227 /* If ARG is a non-negative integer made up solely of digits, return its
 228    value, otherwise return -1.  */
 229 static int
 230 integral_argument (const char *arg)
 231 {
 232   const char *p = arg;
 233
 234   while (*p && ISDIGIT (*p))
 235     p++;
 236
 237   if (*p == '\0')
 238     return atoi (arg);
 239
 240   return -1;
 241 }
 242
 243 /* Return a malloced slash-separated list of languages in MASK.  */
 244 static char *
 245 write_langs (unsigned int mask)
 246 {
 247   unsigned int n = 0, len = 0;
 248   const char *lang_name;
 249   char *result;
 250
 251   for (n = 0; (lang_name = lang_names[n]) != 0; n++)
 252     if (mask & (1U << n))
 253       len += strlen (lang_name) + 1;
 254
 255   result = xmalloc (len);
 256   len = 0;
 257   for (n = 0; (lang_name = lang_names[n]) != 0; n++)
 258     if (mask & (1U << n))
 259       {
 260         if (len)
 261           result[len++] = '/';
 262         strcpy (result + len, lang_name);
 263         len += strlen (lang_name);
 264       }
 265
 266   result[len] = 0;
 267
 268   return result;
 269 }
 270
 271 /* Complain that switch OPT_INDEX does not apply to this front end.  */
 272 static void
 273 complain_wrong_lang (const char *text, const struct cl_option *option,
 274                      unsigned int lang_mask)
 275 {
 276   char *ok_langs, *bad_lang;
 277
 278   ok_langs = write_langs (option->flags);
 279   bad_lang = write_langs (lang_mask);
 280
 281   /* Eventually this should become a hard error IMO.  */
 282   warning ("command line option \"%s\" is valid for %s but not for %s",
 283            text, ok_langs, bad_lang);
 284
 285   free (ok_langs);
 286   free (bad_lang);
 287 }
 288
 289 /* Handle the switch beginning at ARGV for the language indicated by
 290    LANG_MASK.  Returns the number of switches consumed.  */
 291 static unsigned int
 292 handle_option (const char **argv, unsigned int lang_mask)
 293 {
 294   size_t opt_index;
 295   const char *opt, *arg = 0;
 296   char *dup = 0;
 297   int value = 1;
 298   unsigned int result = 0;
 299   const struct cl_option *option;
 300
 301   opt = argv[0];
 302
 303   /* Drop the "no-" from negative switches.  */
 304   if ((opt[1] == 'W' || opt[1] == 'f')
 305       && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
 306     {
 307       size_t len = strlen (opt) - 3;
 308
 309       dup = xmalloc (len + 1);
 310       dup[0] = '-';
 311       dup[1] = opt[1];
 312       memcpy (dup + 2, opt + 5, len - 2 + 1);
 313       opt = dup;
 314       value = 0;
 315     }
 316
 317   opt_index = find_opt (opt + 1, lang_mask | CL_COMMON);
 318   if (opt_index == cl_options_count)
 319     goto done;
 320
 321   option = &cl_options[opt_index];
 322
 323   /* Reject negative form of switches that don't take negatives as
 324      unrecognized.  */
 325   if (!value && (option->flags & CL_REJECT_NEGATIVE))
 326     goto done;
 327
 328   /* We've recognized this switch.  */
 329   result = 1;
 330
 331   /* Sort out any argument the switch takes.  */
 332   if (option->flags & CL_JOINED)
 333     {
 334       /* Have arg point to the original switch.  This is because
 335          some code, such as disable_builtin_function, expects its
 336          argument to be persistent until the program exits.  */
 337       arg = argv[0] + cl_options[opt_index].opt_len + 1;
 338       if (!value)
 339         arg += strlen ("no-");
 340
 341       if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
 342         {
 343           if (option->flags & CL_SEPARATE)
 344             {
 345               arg = argv[1];
 346               result = 2;
 347             }
 348           else
 349             /* Missing argument.  */
 350             arg = NULL;
 351         }
 352     }
 353   else if (option->flags & CL_SEPARATE)
 354     {
 355       arg = argv[1];
 356       result = 2;
 357     }
 358
 359   /* Now we've swallowed any potential argument, complain if this
 360      is a switch for a different front end.  */
 361   if (!(option->flags & (lang_mask | CL_COMMON)))
 362     {
 363       complain_wrong_lang (argv[0], option, lang_mask);
 364       goto done;
 365     }
 366
 367   if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
 368     {
 369       if (!(*lang_hooks.missing_argument) (opt, opt_index))
 370         error ("missing argument to \"%s\"", opt);
 371       goto done;
 372     }
 373
 374   /* If the switch takes an integer, convert it.  */
 375   if (arg && (option->flags & CL_UINTEGER))
 376     {
 377       value = integral_argument (arg);
 378       if (value == -1)
 379         {
 380           error ("argument to \"%s\" should be a non-negative integer",
 381                  option->opt_text);
 382           goto done;
 383         }
 384     }
 385
 386   if (option->flags & lang_mask)
 387     if ((*lang_hooks.handle_option) (opt_index, arg, value) == 0)
 388       result = 0;
 389
 390   if (result && (option->flags & CL_COMMON))
 391     if (common_handle_option (opt_index, arg, value) == 0)
 392       result = 0;
 393
 394  done:
 395   if (dup)
 396     free (dup);
 397   return result;
 398 }
 399
 400 /* Decode and handle the vector of command line options.  LANG_MASK
 401    contains has a single bit set representing the current
 402    language.  */
 403 static void
 404 handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
 405 {
 406   unsigned int n, i;
 407
 408   for (i = 1; i < argc; i += n)
 409     {
 410       const char *opt = argv[i];
 411
 412       /* Interpret "-" or a non-switch as a file name.  */
 413       if (opt[0] != '-' || opt[1] == '\0')
 414         {
 415           main_input_filename = opt;
 416           (*lang_hooks.handle_filename) (opt);
 417           n = 1;
 418           continue;
 419         }
 420
 421       n = handle_option (argv + i, lang_mask);
 422
 423       if (!n)
 424         {
 425           n = 1;
 426           error ("unrecognized command line option \"%s\"", opt);
 427         }
 428     }
 429 }
 430
 431 /* Parse command line options and set default flag values.  Do minimal
 432    options processing.  */
 433 void
 434 decode_options (unsigned int argc, const char **argv)
 435 {
 436   unsigned int i, lang_mask;
 437
 438   /* Perform language-specific options initialization.  */
 439   lang_mask = (*lang_hooks.init_options) (argc, argv);
 440
 441   /* Scan to see what optimization level has been specified.  That will
 442      determine the default value of many flags.  */
 443   for (i = 1; i < argc; i++)
 444     {
 445       if (!strcmp (argv[i], "-O"))
 446         {
 447           optimize = 1;
 448           optimize_size = 0;
 449         }
 450       else if (argv[i][0] == '-' && argv[i][1] == 'O')
 451         {
 452           /* Handle -Os, -O2, -O3, -O69, ...  */
 453           const char *p = &argv[i][2];
 454
 455           if ((p[0] == 's') && (p[1] == 0))
 456             {
 457               optimize_size = 1;
 458
 459               /* Optimizing for size forces optimize to be 2.  */
 460               optimize = 2;
 461             }
 462           else
 463             {
 464               const int optimize_val = read_integral_parameter (p, p - 2, -1);
 465               if (optimize_val != -1)
 466                 {
 467                   optimize = optimize_val;
 468                   optimize_size = 0;
 469                 }
 470             }
 471         }
 472     }
 473
 474   if (!optimize)
 475     {
 476       flag_merge_constants = 0;
 477     }
 478
 479   if (optimize >= 1)
 480     {
 481       flag_defer_pop = 1;
 482       flag_thread_jumps = 1;
 483 #ifdef DELAY_SLOTS
 484       flag_delayed_branch = 1;
 485 #endif
 486 #ifdef CAN_DEBUG_WITHOUT_FP
 487       flag_omit_frame_pointer = 1;
 488 #endif
 489       flag_guess_branch_prob = 1;
 490       flag_cprop_registers = 1;
 491       flag_loop_optimize = 1;
 492       flag_crossjumping = 1;
 493       flag_if_conversion = 1;
 494       flag_if_conversion2 = 1;
 495     }
 496
 497   if (optimize >= 2)
 498     {
 499       flag_optimize_sibling_calls = 1;
 500       flag_cse_follow_jumps = 1;
 501       flag_cse_skip_blocks = 1;
 502       flag_gcse = 1;
 503       flag_expensive_optimizations = 1;
 504       flag_strength_reduce = 1;
 505       flag_rerun_cse_after_loop = 1;
 506       flag_rerun_loop_opt = 1;
 507       flag_caller_saves = 1;
 508       flag_force_mem = 1;
 509       flag_peephole2 = 1;
 510 #ifdef INSN_SCHEDULING
 511       flag_schedule_insns = 1;
 512       flag_schedule_insns_after_reload = 1;
 513 #endif
 514       flag_regmove = 1;
 515       flag_strict_aliasing = 1;
 516       flag_delete_null_pointer_checks = 1;
 517       flag_reorder_blocks = 1;
 518       flag_reorder_functions = 1;
 519     }
 520
 521   if (optimize >= 3)
 522     {
 523       flag_inline_functions = 1;
 524       flag_rename_registers = 1;
 525       flag_unswitch_loops = 1;
 526       flag_unit_at_a_time = 1;
 527     }
 528
 529   if (optimize < 2 || optimize_size)
 530     {
 531       align_loops = 1;
 532       align_jumps = 1;
 533       align_labels = 1;
 534       align_functions = 1;
 535
 536       /* Don't reorder blocks when optimizing for size because extra
 537          jump insns may be created; also barrier may create extra padding.
 538
 539          More correctly we should have a block reordering mode that tried
 540          to minimize the combined size of all the jumps.  This would more
 541          or less automatically remove extra jumps, but would also try to
 542          use more short jumps instead of long jumps.  */
 543       flag_reorder_blocks = 0;
 544     }
 545
 546   /* Initialize whether `char' is signed.  */
 547   flag_signed_char = DEFAULT_SIGNED_CHAR;
 548 #ifdef DEFAULT_SHORT_ENUMS
 549   /* Initialize how much space enums occupy, by default.  */
 550   flag_short_enums = DEFAULT_SHORT_ENUMS;
 551 #endif
 552
 553   /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
 554      modify it.  */
 555   target_flags = 0;
 556   set_target_switch ("");
 557
 558   /* Unwind tables are always present in an ABI-conformant IA-64
 559      object file, so the default should be ON.  */
 560 #ifdef IA64_UNWIND_INFO
 561   flag_unwind_tables = IA64_UNWIND_INFO;
 562 #endif
 563
 564 #ifdef OPTIMIZATION_OPTIONS
 565   /* Allow default optimizations to be specified on a per-machine basis.  */
 566   OPTIMIZATION_OPTIONS (optimize, optimize_size);
 567 #endif
 568
 569   handle_options (argc, argv, lang_mask);
 570
 571   if (flag_pie)
 572     flag_pic = flag_pie;
 573   if (flag_pic && !flag_pie)
 574     flag_shlib = 1;
 575
 576   if (flag_no_inline == 2)
 577     flag_no_inline = 0;
 578   else
 579     flag_really_no_inline = flag_no_inline;
 580
 581   /* Set flag_no_inline before the post_options () hook.  The C front
 582      ends use it to determine tree inlining defaults.  FIXME: such
 583      code should be lang-independent when all front ends use tree
 584      inlining, in which case it, and this condition, should be moved
 585      to the top of process_options() instead.  */
 586   if (optimize == 0)
 587     {
 588       /* Inlining does not work if not optimizing,
 589          so force it not to be done.  */
 590       flag_no_inline = 1;
 591       warn_inline = 0;
 592
 593       /* The c_decode_option function and decode_option hook set
 594          this to `2' if -Wall is used, so we can avoid giving out
 595          lots of errors for people who don't realize what -Wall does.  */
 596       if (warn_uninitialized == 1)
 597         warning ("-Wuninitialized is not supported without -O");
 598     }
 599
 600   if (flag_really_no_inline == 2)
 601     flag_really_no_inline = flag_no_inline;
 602 }
 603
 604 /* Handle target- and language-independent options.  Return zero to
 605    generate an "unknown option" message.  */
 606 static int
 607 common_handle_option (size_t scode, const char *arg,
 608                       int value ATTRIBUTE_UNUSED)
 609 {
 610   enum opt_code code = (enum opt_code) scode;
 611
 612   switch (code)
 613     {
 614     default:
 615       abort ();
 616
 617     case OPT__help:
 618       print_help ();
 619       exit_after_options = true;
 620       break;
 621
 622     case OPT__param:
 623       handle_param (arg);
 624       break;
 625
 626     case OPT__target_help:
 627       display_target_options ();
 628       exit_after_options = true;
 629       break;
 630
 631     case OPT__version:
 632       print_version (stderr, "");
 633       exit_after_options = true;
 634       break;
 635
 636     case OPT_G:
 637       g_switch_value = value;
 638       g_switch_set = true;
 639       break;
 640
 641     case OPT_O:
 642     case OPT_Os:
 643       /* Currently handled in a prescan.  */
 644       break;
 645
 646     case OPT_W:
 647       /* For backward compatibility, -W is the same as -Wextra.  */
 648       set_Wextra (value);
 649       break;
 650
 651     case OPT_Waggregate_return:
 652       warn_aggregate_return = value;
 653       break;
 654
 655     case OPT_Wcast_align:
 656       warn_cast_align = value;
 657       break;
 658
 659     case OPT_Wdeprecated_declarations:
 660       warn_deprecated_decl = value;
 661       break;
 662
 663     case OPT_Wdisabled_optimization:
 664       warn_disabled_optimization = value;
 665       break;
 666
 667     case OPT_Werror:
 668       warnings_are_errors = value;
 669       break;
 670
 671     case OPT_Wextra:
 672       set_Wextra (value);
 673       break;
 674
 675     case OPT_Winline:
 676       warn_inline = value;
 677       break;
 678
 679     case OPT_Wlarger_than_:
 680       larger_than_size = value;
 681       warn_larger_than = value != -1;
 682       break;
 683
 684     case OPT_Wmissing_noreturn:
 685       warn_missing_noreturn = value;
 686       break;
 687
 688     case OPT_Wpacked:
 689       warn_packed = value;
 690       break;
 691
 692     case OPT_Wpadded:
 693       warn_padded = value;
 694       break;
 695
 696     case OPT_Wshadow:
 697       warn_shadow = value;
 698       break;
 699
 700     case OPT_Wstrict_aliasing:
 701       warn_strict_aliasing = value;
 702       break;
 703
 704     case OPT_Wswitch:
 705       warn_switch = value;
 706       break;
 707
 708     case OPT_Wswitch_default:
 709       warn_switch_default = value;
 710       break;
 711
 712     case OPT_Wswitch_enum:
 713       warn_switch_enum = value;
 714       break;
 715
 716     case OPT_Wsystem_headers:
 717       warn_system_headers = value;
 718       break;
 719
 720     case OPT_Wuninitialized:
 721       warn_uninitialized = value;
 722       break;
 723
 724     case OPT_Wunreachable_code:
 725       warn_notreached = value;
 726       break;
 727
 728     case OPT_Wunused:
 729       set_Wunused (value);
 730       break;
 731
 732     case OPT_Wunused_function:
 733       warn_unused_function = value;
 734       break;
 735
 736     case OPT_Wunused_label:
 737       warn_unused_label = value;
 738       break;
 739
 740     case OPT_Wunused_parameter:
 741       warn_unused_parameter = value;
 742       break;
 743
 744     case OPT_Wunused_value:
 745       warn_unused_value = value;
 746       break;
 747
 748     case OPT_Wunused_variable:
 749       warn_unused_variable = value;
 750       break;
 751
 752     case OPT_aux_info:
 753     case OPT_aux_info_:
 754       aux_info_file_name = arg;
 755       flag_gen_aux_info = 1;
 756       break;
 757
 758     case OPT_auxbase:
 759       aux_base_name = arg;
 760       break;
 761
 762     case OPT_auxbase_strip:
 763       {
 764         char *tmp = xstrdup (arg);
 765         strip_off_ending (tmp, strlen (tmp));
 766         if (tmp[0])
 767           aux_base_name = tmp;
 768       }
 769       break;
 770
 771     case OPT_d:
 772       decode_d_option (arg);
 773       break;
 774
 775     case OPT_dumpbase:
 776       dump_base_name = arg;
 777       break;
 778
 779     case OPT_fPIC:
 780       flag_pic = value + value;
 781       break;
 782
 783     case OPT_fPIE:
 784       flag_pie = value + value;
 785       break;
 786
 787     case OPT_falign_functions:
 788       align_functions = !value;
 789       break;
 790
 791     case OPT_falign_functions_:
 792       align_functions = value;
 793       break;
 794
 795     case OPT_falign_jumps:
 796       align_jumps = !value;
 797       break;
 798
 799     case OPT_falign_jumps_:
 800       align_jumps = value;
 801       break;
 802
 803     case OPT_falign_labels:
 804       align_labels = !value;
 805       break;
 806
 807     case OPT_falign_labels_:
 808       align_labels = value;
 809       break;
 810
 811     case OPT_falign_loops:
 812       align_loops = !value;
 813       break;
 814
 815     case OPT_falign_loops_:
 816       align_loops = value;
 817       break;
 818
 819     case OPT_fargument_alias:
 820       flag_argument_noalias = !value;
 821       break;
 822
 823     case OPT_fargument_noalias:
 824       flag_argument_noalias = value;
 825       break;
 826
 827     case OPT_fargument_noalias_global:
 828       flag_argument_noalias = value + value;
 829       break;
 830
 831     case OPT_fasynchronous_unwind_tables:
 832       flag_asynchronous_unwind_tables = value;
 833       break;
 834
 835     case OPT_fbounds_check:
 836       flag_bounds_check = value;
 837       break;
 838
 839     case OPT_fbranch_count_reg:
 840       flag_branch_on_count_reg = value;
 841       break;
 842
 843     case OPT_fbranch_probabilities:
 844       flag_branch_probabilities = value;
 845       break;
 846
 847     case OPT_fbranch_target_load_optimize:
 848       flag_branch_target_load_optimize = value;
 849       break;
 850
 851     case OPT_fbranch_target_load_optimize2:
 852       flag_branch_target_load_optimize2 = value;
 853       break;
 854
 855     case OPT_fcall_used_:
 856       fix_register (arg, 0, 1);
 857       break;
 858
 859     case OPT_fcall_saved_:
 860       fix_register (arg, 0, 0);
 861       break;
 862
 863     case OPT_fcaller_saves:
 864       flag_caller_saves = value;
 865       break;
 866
 867     case OPT_fcommon:
 868       flag_no_common = !value;
 869       break;
 870
 871     case OPT_fcprop_registers:
 872       flag_cprop_registers = value;
 873       break;
 874
 875     case OPT_fcrossjumping:
 876       flag_crossjumping = value;
 877       break;
 878
 879     case OPT_fcse_follow_jumps:
 880       flag_cse_follow_jumps = value;
 881       break;
 882
 883     case OPT_fcse_skip_blocks:
 884       flag_cse_skip_blocks = value;
 885       break;
 886
 887     case OPT_fdata_sections:
 888       flag_data_sections = value;
 889       break;
 890
 891     case OPT_fdefer_pop:
 892       flag_defer_pop = value;
 893       break;
 894
 895     case OPT_fdelayed_branch:
 896       flag_delayed_branch = value;
 897       break;
 898
 899     case OPT_fdelete_null_pointer_checks:
 900       flag_delete_null_pointer_checks = value;
 901       break;
 902
 903     case OPT_fdiagnostics_show_location_:
 904       if (!strcmp (arg, "once"))
 905         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 906       else if (!strcmp (arg, "every-line"))
 907         diagnostic_prefixing_rule (global_dc)
 908           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
 909       else
 910         return 0;
 911       break;
 912
 913     case OPT_fdump_unnumbered:
 914       flag_dump_unnumbered = value;
 915       break;
 916
 917     case OPT_feliminate_dwarf2_dups:
 918       flag_eliminate_dwarf2_dups = value;
 919       break;
 920
 921     case OPT_feliminate_unused_debug_types:
 922       flag_eliminate_unused_debug_types = value;
 923       break;
 924
 925     case OPT_feliminate_unused_debug_symbols:
 926       flag_debug_only_used_symbols = value;
 927       break;
 928
 929     case OPT_fexceptions:
 930       flag_exceptions = value;
 931       break;
 932
 933     case OPT_fexpensive_optimizations:
 934       flag_expensive_optimizations = value;
 935       break;
 936
 937     case OPT_ffast_math:
 938       set_fast_math_flags (value);
 939       break;
 940
 941     case OPT_ffinite_math_only:
 942       flag_finite_math_only = value;
 943       break;
 944
 945     case OPT_ffixed_:
 946       fix_register (arg, 1, 1);
 947       break;
 948
 949     case OPT_ffunction_cse:
 950       flag_no_function_cse = !value;
 951       break;
 952
 953     case OPT_ffloat_store:
 954       flag_float_store = value;
 955       break;
 956
 957     case OPT_fforce_addr:
 958       flag_force_addr = value;
 959       break;
 960
 961     case OPT_fforce_mem:
 962       flag_force_mem = value;
 963       break;
 964
 965     case OPT_ffunction_sections:
 966       flag_function_sections = value;
 967       break;
 968
 969     case OPT_fgcse:
 970       flag_gcse = value;
 971       break;
 972
 973     case OPT_fgcse_lm:
 974       flag_gcse_lm = value;
 975       break;
 976
 977     case OPT_fgcse_sm:
 978       flag_gcse_sm = value;
 979       break;
 980
 981     case OPT_fgnu_linker:
 982       flag_gnu_linker = value;
 983       break;
 984
 985     case OPT_fguess_branch_probability:
 986       flag_guess_branch_prob = value;
 987       break;
 988
 989     case OPT_fident:
 990       flag_no_ident = !value;
 991       break;
 992
 993     case OPT_fif_conversion:
 994       flag_if_conversion = value;
 995       break;
 996
 997     case OPT_fif_conversion2:
 998       flag_if_conversion2 = value;
 999       break;
1000
1001     case OPT_finhibit_size_directive:
1002       flag_inhibit_size_directive = value;
1003       break;
1004
1005     case OPT_finline:
1006       flag_no_inline = !value;
1007       break;
1008
1009     case OPT_finline_functions:
1010       flag_inline_functions = value;
1011       break;
1012
1013     case OPT_finline_limit_:
1014     case OPT_finline_limit_eq:
1015       set_param_value ("max-inline-insns", value);
1016       set_param_value ("max-inline-insns-single", value / 2);
1017       set_param_value ("max-inline-insns-auto", value / 2);
1018       set_param_value ("max-inline-insns-rtl", value);
1019       if (value / 4 < MIN_INLINE_INSNS)
1020         {
1021           if (value / 4 > 10)
1022             set_param_value ("min-inline-insns", value / 4);
1023           else
1024             set_param_value ("min-inline-insns", 10);
1025         }
1026       break;
1027
1028     case OPT_finstrument_functions:
1029       flag_instrument_function_entry_exit = value;
1030       break;
1031
1032     case OPT_fkeep_inline_functions:
1033       flag_keep_inline_functions =value;
1034       break;
1035
1036     case OPT_fkeep_static_consts:
1037       flag_keep_static_consts = value;
1038       break;
1039
1040     case OPT_fleading_underscore:
1041       flag_leading_underscore = value;
1042       break;
1043
1044     case OPT_floop_optimize:
1045       flag_loop_optimize = value;
1046       break;
1047
1048     case OPT_fmath_errno:
1049       flag_errno_math = value;
1050       break;
1051
1052     case OPT_fmem_report:
1053       mem_report = value;
1054       break;
1055
1056     case OPT_fmerge_all_constants:
1057       flag_merge_constants = value + value;
1058       break;
1059
1060     case OPT_fmerge_constants:
1061       flag_merge_constants = value;
1062       break;
1063
1064     case OPT_fmessage_length_:
1065       output_set_maximum_length (&global_dc->buffer, value);
1066       break;
1067
1068     case OPT_fmove_all_movables:
1069       flag_move_all_movables = value;
1070       break;
1071
1072     case OPT_fnew_ra:
1073       flag_new_regalloc = value;
1074       break;
1075
1076     case OPT_fnon_call_exceptions:
1077       flag_non_call_exceptions = value;
1078       break;
1079
1080     case OPT_fold_unroll_all_loops:
1081       flag_old_unroll_all_loops = value;
1082       break;
1083
1084     case OPT_fold_unroll_loops:
1085       flag_old_unroll_loops = value;
1086       break;
1087
1088     case OPT_fomit_frame_pointer:
1089       flag_omit_frame_pointer = value;
1090       break;
1091
1092     case OPT_foptimize_register_move:
1093       flag_regmove = value;
1094       break;
1095
1096     case OPT_foptimize_sibling_calls:
1097       flag_optimize_sibling_calls = value;
1098       break;
1099
1100     case OPT_fpack_struct:
1101       flag_pack_struct = value;
1102       break;
1103
1104     case OPT_fpeel_loops:
1105       flag_peel_loops = value;
1106       break;
1107
1108     case OPT_fpcc_struct_return:
1109       flag_pcc_struct_return = value;
1110       break;
1111
1112     case OPT_fpeephole:
1113       flag_no_peephole = !value;
1114       break;
1115
1116     case OPT_fpeephole2:
1117       flag_peephole2 = value;
1118       break;
1119
1120     case OPT_fpic:
1121       flag_pic = value;
1122       break;
1123
1124     case OPT_fpie:
1125       flag_pie = value;
1126       break;
1127
1128     case OPT_fprefetch_loop_arrays:
1129       flag_prefetch_loop_arrays = value;
1130       break;
1131
1132     case OPT_fprofile:
1133       profile_flag = value;
1134       break;
1135
1136     case OPT_fprofile_arcs:
1137       profile_arc_flag = value;
1138       break;
1139
1140     case OPT_frandom_seed:
1141       /* The real switch is -fno-random-seed.  */
1142       if (value)
1143         return 0;
1144       flag_random_seed = NULL;
1145       break;
1146
1147     case OPT_frandom_seed_:
1148       flag_random_seed = arg;
1149       break;
1150
1151     case OPT_freduce_all_givs:
1152       flag_reduce_all_givs = value;
1153       break;
1154
1155     case OPT_freg_struct_return:
1156       flag_pcc_struct_return = !value;
1157       break;
1158
1159     case OPT_fregmove:
1160       flag_regmove = value;
1161       break;
1162
1163     case OPT_frename_registers:
1164       flag_rename_registers = value;
1165       break;
1166
1167     case OPT_freorder_blocks:
1168       flag_reorder_blocks = value;
1169       break;
1170
1171     case OPT_freorder_functions:
1172       flag_reorder_functions = value;
1173       break;
1174
1175     case OPT_frerun_cse_after_loop:
1176       flag_rerun_cse_after_loop = value;
1177       break;
1178
1179     case OPT_frerun_loop_opt:
1180       flag_rerun_loop_opt = value;
1181       break;
1182
1183     case OPT_fsched_interblock:
1184       flag_schedule_interblock= value;
1185       break;
1186
1187     case OPT_fsched_spec:
1188       flag_schedule_speculative = value;
1189       break;
1190
1191     case OPT_fsched_spec_load:
1192       flag_schedule_speculative_load = value;
1193       break;
1194
1195     case OPT_fsched_spec_load_dangerous:
1196       flag_schedule_speculative_load_dangerous = value;
1197       break;
1198
1199     case OPT_fsched_verbose_:
1200 #ifdef INSN_SCHEDULING
1201       fix_sched_param ("verbose", arg);
1202       break;
1203 #else
1204       return 0;
1205 #endif
1206
1207     case OPT_fsched2_use_superblocks:
1208       flag_sched2_use_superblocks = value;
1209       break;
1210
1211     case OPT_fsched2_use_traces:
1212       flag_sched2_use_traces = value;
1213       break;
1214
1215     case OPT_fschedule_insns:
1216       flag_schedule_insns = value;
1217       break;
1218
1219     case OPT_fschedule_insns2:
1220       flag_schedule_insns_after_reload = value;
1221       break;
1222
1223     case OPT_fshared_data:
1224       flag_shared_data = value;
1225       break;
1226
1227     case OPT_fsignaling_nans:
1228       flag_signaling_nans = value;
1229       break;
1230
1231     case OPT_fsingle_precision_constant:
1232       flag_single_precision_constant = value;
1233       break;
1234
1235     case OPT_fssa:
1236       flag_ssa = value;
1237       break;
1238
1239     case OPT_fssa_ccp:
1240       flag_ssa_ccp = value;
1241       break;
1242
1243     case OPT_fssa_dce:
1244       flag_ssa_dce = value;
1245       break;
1246
1247     case OPT_fstack_check:
1248       flag_stack_check = value;
1249       break;
1250
1251     case OPT_fstack_limit:
1252       /* The real switch is -fno-stack-limit.  */
1253       if (value)
1254         return 0;
1255       stack_limit_rtx = NULL_RTX;
1256       break;
1257
1258     case OPT_fstack_limit_register_:
1259       {
1260         int reg = decode_reg_name (arg);
1261         if (reg < 0)
1262           error ("unrecognized register name \"%s\"", arg);
1263         else
1264           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1265       }
1266       break;
1267
1268     case OPT_fstack_limit_symbol_:
1269       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1270       break;
1271
1272     case OPT_fstrength_reduce:
1273       flag_strength_reduce = value;
1274       break;
1275
1276     case OPT_fstrict_aliasing:
1277       flag_strict_aliasing = value;
1278       break;
1279
1280     case OPT_fsyntax_only:
1281       flag_syntax_only = value;
1282       break;
1283
1284     case OPT_ftest_coverage:
1285       flag_test_coverage = value;
1286       break;
1287
1288     case OPT_fthread_jumps:
1289       flag_thread_jumps = value;
1290       break;
1291
1292     case OPT_ftime_report:
1293       time_report = value;
1294       break;
1295
1296     case OPT_ftls_model_:
1297       if (!strcmp (arg, "global-dynamic"))
1298         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1299       else if (!strcmp (arg, "local-dynamic"))
1300         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1301       else if (!strcmp (arg, "initial-exec"))
1302         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1303       else if (!strcmp (arg, "local-exec"))
1304         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1305       else
1306         warning ("unknown tls-model \"%s\"", arg);
1307       break;
1308
1309     case OPT_ftracer:
1310       flag_tracer = value;
1311       break;
1312
1313     case OPT_ftrapping_math:
1314       flag_trapping_math = value;
1315       break;
1316
1317     case OPT_ftrapv:
1318       flag_trapv = value;
1319       break;
1320
1321     case OPT_funit_at_a_time:
1322       flag_unit_at_a_time = value;
1323       break;
1324
1325     case OPT_funroll_all_loops:
1326       flag_unroll_all_loops = value;
1327       break;
1328
1329     case OPT_funroll_loops:
1330       flag_unroll_loops = value;
1331       break;
1332
1333     case OPT_funsafe_math_optimizations:
1334       flag_unsafe_math_optimizations = value;
1335       break;
1336
1337     case OPT_funswitch_loops:
1338       flag_unswitch_loops = value;
1339       break;
1340
1341     case OPT_funwind_tables:
1342       flag_unwind_tables = value;
1343       break;
1344
1345     case OPT_fverbose_asm:
1346       flag_verbose_asm = value;
1347       break;
1348
1349     case OPT_fwrapv:
1350       flag_wrapv = value;
1351       break;
1352
1353     case OPT_fwritable_strings:
1354       flag_writable_strings = value;
1355       break;
1356
1357     case OPT_fzero_initialized_in_bss:
1358       flag_zero_initialized_in_bss = value;
1359       break;
1360
1361     case OPT_g:
1362       decode_g_option (arg);
1363       break;
1364
1365     case OPT_m:
1366       set_target_switch (arg);
1367       break;
1368
1369     case OPT_o:
1370       asm_file_name = arg;
1371       break;
1372
1373     case OPT_p:
1374       profile_flag = 1;
1375       break;
1376
1377     case OPT_pedantic:
1378       pedantic = 1;
1379       break;
1380
1381     case OPT_pedantic_errors:
1382       flag_pedantic_errors = pedantic = 1;
1383       break;
1384
1385     case OPT_quiet:
1386       quiet_flag = 1;
1387       break;
1388
1389     case OPT_version:
1390       version_flag = 1;
1391       break;
1392
1393     case OPT_w:
1394       inhibit_warnings = true;
1395       break;
1396     }
1397
1398   return 1;
1399 }
1400
1401 /* Handle --param NAME=VALUE.  */
1402 static void
1403 handle_param (const char *carg)
1404 {
1405   char *equal, *arg;
1406   int value;
1407
1408   arg = xstrdup (carg);
1409   equal = strchr (arg, '=');
1410   if (!equal)
1411     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1412   else
1413     {
1414       value = integral_argument (equal + 1);
1415       if (value == -1)
1416         error ("invalid --param value `%s'", equal + 1);
1417       else
1418         {
1419           *equal = '\0';
1420           set_param_value (arg, value);
1421         }
1422     }
1423
1424   free (arg);
1425 }
1426
1427 /* Handle -W and -Wextra.  */
1428 static void
1429 set_Wextra (int setting)
1430 {
1431   extra_warnings = setting;
1432   warn_unused_value = setting;
1433   warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1434
1435   /* We save the value of warn_uninitialized, since if they put
1436      -Wuninitialized on the command line, we need to generate a
1437      warning about not using it without also specifying -O.  */
1438   if (setting == 0)
1439     warn_uninitialized = 0;
1440   else if (warn_uninitialized != 1)
1441     warn_uninitialized = 2;
1442 }
1443
1444 /* Initialize unused warning flags.  */
1445 void
1446 set_Wunused (int setting)
1447 {
1448   warn_unused_function = setting;
1449   warn_unused_label = setting;
1450   /* Unused function parameter warnings are reported when either
1451      ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1452      Thus, if -Wextra has already been seen, set warn_unused_parameter;
1453      otherwise set maybe_warn_extra_parameter, which will be picked up
1454      by set_Wextra.  */
1455   maybe_warn_unused_parameter = setting;
1456   warn_unused_parameter = (setting && extra_warnings);
1457   warn_unused_variable = setting;
1458   warn_unused_value = setting;
1459 }
1460
1461 /* The following routines are useful in setting all the flags that
1462    -ffast-math and -fno-fast-math imply.  */
1463 void
1464 set_fast_math_flags (int set)
1465 {
1466   flag_trapping_math = !set;
1467   flag_unsafe_math_optimizations = set;
1468   flag_finite_math_only = set;
1469   flag_errno_math = !set;
1470   if (set)
1471     flag_signaling_nans = 0;
1472 }
1473
1474 /* Return true iff flags are set as if -ffast-math.  */
1475 bool
1476 fast_math_flags_set_p (void)
1477 {
1478   return (!flag_trapping_math
1479           && flag_unsafe_math_optimizations
1480           && flag_finite_math_only
1481           && !flag_errno_math);
1482 }
1483
1484 /* Output --help text.  */
1485 static void
1486 print_help (void)
1487 {
1488   size_t i, len;
1489
1490   puts (_("\nThe following options are language-independent:\n"));
1491
1492   for (i = 0; i < cl_options_count; i++)
1493     {
1494       const char *help = cl_options[i].help;
1495       const char *opt, *tab;
1496
1497       /* During transition, ignore switches with no help.  */
1498       if (!help)
1499         continue;
1500
1501       /* Get the translation.  */
1502       help = _(help);
1503
1504       tab = strchr (help, '\t');
1505       if (tab)
1506         {
1507           len = tab - help;
1508           opt = help;
1509           help = tab + 1;
1510         }
1511       else
1512         {
1513           opt = cl_options[i].opt_text;
1514           len = strlen (opt);
1515         }
1516
1517       wrap_help (help, opt, len);
1518     }
1519
1520   puts ( "\n" );
1521   display_help ();
1522 }
1523
1524 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1525    word-wrapped HELP in a second column.  */
1526 static void
1527 wrap_help (const char *help, const char *item, int item_width)
1528 {
1529   const int columns = 80, col_width = 27;
1530   unsigned int remaining, room, len;
1531
1532   remaining = strlen (help);
1533
1534   do
1535     {
1536       room = columns - 3 - MAX (col_width, item_width);
1537       len = remaining;
1538
1539       if (room < len)
1540         {
1541           unsigned int i;
1542
1543           for (i = 0; help[i]; i++)
1544             {
1545               if (i >= room && len != remaining)
1546                 break;
1547               if (help[i] == ' ')
1548                 len = i;
1549               else if (help[i] == '-')
1550                 len = i + 1;
1551             }
1552         }
1553
1554       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1555       item_width = 0;
1556       while (help[len] == ' ')
1557         len++;
1558       help += len;
1559       remaining -= len;
1560     }
1561   while (remaining);
1562 }