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