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