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