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