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