gcc/opts.c

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