gcc/opts.c

   1 /* Command line option handling.
   2    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   3    Free Software Foundation, Inc.
   4    Contributed by Neil Booth.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  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 "expr.h"
  30 #include "ggc.h"
  31 #include "output.h"
  32 #include "langhooks.h"
  33 #include "opts.h"
  34 #include "options.h"
  35 #include "flags.h"
  36 #include "toplev.h"
  37 #include "params.h"
  38 #include "diagnostic.h"
  39 #include "opts-diagnostic.h"
  40 #include "tm_p.h"               /* For OPTIMIZATION_OPTIONS.  */
  41 #include "insn-attr.h"          /* For INSN_SCHEDULING.  */
  42 #include "target.h"
  43 #include "tree-pass.h"
  44 #include "dbgcnt.h"
  45 #include "debug.h"
  46 #include "plugin.h"
  47 #include "except.h"
  48 #include "lto-streamer.h"
  49
  50 /* Value of the -G xx switch, and whether it was passed or not.  */
  51 unsigned HOST_WIDE_INT g_switch_value;
  52 bool g_switch_set;
  53
  54 /* Same for selective scheduling.  */
  55 bool sel_sched_switch_set;
  56
  57 /* True if we should exit after parsing options.  */
  58 bool exit_after_options;
  59
  60 /* True to warn about any objects definitions whose size is larger
  61    than N bytes.  Also want about function definitions whose returned
  62    values are larger than N bytes, where N is `larger_than_size'.  */
  63 bool warn_larger_than;
  64 HOST_WIDE_INT larger_than_size;
  65
  66 /* True to warn about any function whose frame size is larger
  67    than N bytes. */
  68 bool warn_frame_larger_than;
  69 HOST_WIDE_INT frame_larger_than_size;
  70
  71 /* Type(s) of debugging information we are producing (if any).  See
  72    flags.h for the definitions of the different possible types of
  73    debugging information.  */
  74 enum debug_info_type write_symbols = NO_DEBUG;
  75
  76 /* Level of debugging information we are producing.  See flags.h for
  77    the definitions of the different possible levels.  */
  78 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
  79
  80 /* A major contribution to object and executable size is debug
  81    information size.  A major contribution to debug information size
  82    is struct descriptions replicated in several object files. The
  83    following flags attempt to reduce this information.  The basic
  84    idea is to not emit struct debugging information in the current
  85    compilation unit when that information will be generated by
  86    another compilation unit.
  87
  88    Debug information for a struct defined in the current source
  89    file should be generated in the object file.  Likewise the
  90    debug information for a struct defined in a header should be
  91    generated in the object file of the corresponding source file.
  92    Both of these case are handled when the base name of the file of
  93    the struct definition matches the base name of the source file
  94    of the current compilation unit.  This matching emits minimal
  95    struct debugging information.
  96
  97    The base file name matching rule above will fail to emit debug
  98    information for structs defined in system headers.  So a second
  99    category of files includes system headers in addition to files
 100    with matching bases.
 101
 102    The remaining types of files are library headers and application
 103    headers.  We cannot currently distinguish these two types.  */
 104
 105 enum debug_struct_file
 106 {
 107   DINFO_STRUCT_FILE_NONE,   /* Debug no structs. */
 108   DINFO_STRUCT_FILE_BASE,   /* Debug structs defined in files with the
 109                                same base name as the compilation unit. */
 110   DINFO_STRUCT_FILE_SYS,    /* Also debug structs defined in system
 111                                header files.  */
 112   DINFO_STRUCT_FILE_ANY     /* Debug structs defined in all files. */
 113 };
 114
 115 /* Generic structs (e.g. templates not explicitly specialized)
 116    may not have a compilation unit associated with them, and so
 117    may need to be treated differently from ordinary structs.
 118
 119    Structs only handled by reference (indirectly), will also usually
 120    not need as much debugging information.  */
 121
 122 static enum debug_struct_file debug_struct_ordinary[DINFO_USAGE_NUM_ENUMS]
 123   = { DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY };
 124 static enum debug_struct_file debug_struct_generic[DINFO_USAGE_NUM_ENUMS]
 125   = { DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY };
 126
 127 /* Parse the -femit-struct-debug-detailed option value
 128    and set the flag variables. */
 129
 130 #define MATCH( prefix, string ) \
 131   ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
 132    ? ((string += sizeof prefix - 1), 1) : 0)
 133
 134 void
 135 set_struct_debug_option (const char *spec)
 136 {
 137   /* various labels for comparison */
 138   static char dfn_lbl[] = "dfn:", dir_lbl[] = "dir:", ind_lbl[] = "ind:";
 139   static char ord_lbl[] = "ord:", gen_lbl[] = "gen:";
 140   static char none_lbl[] = "none", any_lbl[] = "any";
 141   static char base_lbl[] = "base", sys_lbl[] = "sys";
 142
 143   enum debug_struct_file files = DINFO_STRUCT_FILE_ANY;
 144   /* Default is to apply to as much as possible. */
 145   enum debug_info_usage usage = DINFO_USAGE_NUM_ENUMS;
 146   int ord = 1, gen = 1;
 147
 148   /* What usage? */
 149   if (MATCH (dfn_lbl, spec))
 150     usage = DINFO_USAGE_DFN;
 151   else if (MATCH (dir_lbl, spec))
 152     usage = DINFO_USAGE_DIR_USE;
 153   else if (MATCH (ind_lbl, spec))
 154     usage = DINFO_USAGE_IND_USE;
 155
 156   /* Generics or not? */
 157   if (MATCH (ord_lbl, spec))
 158     gen = 0;
 159   else if (MATCH (gen_lbl, spec))
 160     ord = 0;
 161
 162   /* What allowable environment? */
 163   if (MATCH (none_lbl, spec))
 164     files = DINFO_STRUCT_FILE_NONE;
 165   else if (MATCH (any_lbl, spec))
 166     files = DINFO_STRUCT_FILE_ANY;
 167   else if (MATCH (sys_lbl, spec))
 168     files = DINFO_STRUCT_FILE_SYS;
 169   else if (MATCH (base_lbl, spec))
 170     files = DINFO_STRUCT_FILE_BASE;
 171   else
 172     error ("argument %qs to %<-femit-struct-debug-detailed%> not recognized",
 173            spec);
 174
 175   /* Effect the specification. */
 176   if (usage == DINFO_USAGE_NUM_ENUMS)
 177     {
 178       if (ord)
 179         {
 180           debug_struct_ordinary[DINFO_USAGE_DFN] = files;
 181           debug_struct_ordinary[DINFO_USAGE_DIR_USE] = files;
 182           debug_struct_ordinary[DINFO_USAGE_IND_USE] = files;
 183         }
 184       if (gen)
 185         {
 186           debug_struct_generic[DINFO_USAGE_DFN] = files;
 187           debug_struct_generic[DINFO_USAGE_DIR_USE] = files;
 188           debug_struct_generic[DINFO_USAGE_IND_USE] = files;
 189         }
 190     }
 191   else
 192     {
 193       if (ord)
 194         debug_struct_ordinary[usage] = files;
 195       if (gen)
 196         debug_struct_generic[usage] = files;
 197     }
 198
 199   if (*spec == ',')
 200     set_struct_debug_option (spec+1);
 201   else
 202     {
 203       /* No more -femit-struct-debug-detailed specifications.
 204          Do final checks. */
 205       if (*spec != '\0')
 206         error ("argument %qs to %<-femit-struct-debug-detailed%> unknown",
 207                spec);
 208       if (debug_struct_ordinary[DINFO_USAGE_DIR_USE]
 209                 < debug_struct_ordinary[DINFO_USAGE_IND_USE]
 210           || debug_struct_generic[DINFO_USAGE_DIR_USE]
 211                 < debug_struct_generic[DINFO_USAGE_IND_USE])
 212         error ("%<-femit-struct-debug-detailed=dir:...%> must allow at least"
 213                " as much as %<-femit-struct-debug-detailed=ind:...%>");
 214     }
 215 }
 216
 217 /* Find the base name of a path, stripping off both directories and
 218    a single final extension. */
 219 static int
 220 base_of_path (const char *path, const char **base_out)
 221 {
 222   const char *base = path;
 223   const char *dot = 0;
 224   const char *p = path;
 225   char c = *p;
 226   while (c)
 227     {
 228       if (IS_DIR_SEPARATOR(c))
 229         {
 230           base = p + 1;
 231           dot = 0;
 232         }
 233       else if (c == '.')
 234         dot = p;
 235       c = *++p;
 236     }
 237   if (!dot)
 238     dot = p;
 239   *base_out = base;
 240   return dot - base;
 241 }
 242
 243 /* Match the base name of a file to the base name of a compilation unit. */
 244
 245 static const char *main_input_basename;
 246 static int main_input_baselength;
 247
 248 static int
 249 matches_main_base (const char *path)
 250 {
 251   /* Cache the last query. */
 252   static const char *last_path = NULL;
 253   static int last_match = 0;
 254   if (path != last_path)
 255     {
 256       const char *base;
 257       int length = base_of_path (path, &base);
 258       last_path = path;
 259       last_match = (length == main_input_baselength
 260                     && memcmp (base, main_input_basename, length) == 0);
 261     }
 262   return last_match;
 263 }
 264
 265 #ifdef DEBUG_DEBUG_STRUCT
 266
 267 static int
 268 dump_struct_debug (tree type, enum debug_info_usage usage,
 269                    enum debug_struct_file criterion, int generic,
 270                    int matches, int result)
 271 {
 272   /* Find the type name. */
 273   tree type_decl = TYPE_STUB_DECL (type);
 274   tree t = type_decl;
 275   const char *name = 0;
 276   if (TREE_CODE (t) == TYPE_DECL)
 277     t = DECL_NAME (t);
 278   if (t)
 279     name = IDENTIFIER_POINTER (t);
 280
 281   fprintf (stderr, "    struct %d %s %s %s %s %d %p %s\n",
 282            criterion,
 283            DECL_IN_SYSTEM_HEADER (type_decl) ? "sys" : "usr",
 284            matches ? "bas" : "hdr",
 285            generic ? "gen" : "ord",
 286            usage == DINFO_USAGE_DFN ? ";" :
 287              usage == DINFO_USAGE_DIR_USE ? "." : "*",
 288            result,
 289            (void*) type_decl, name);
 290   return result;
 291 }
 292 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
 293   dump_struct_debug (type, usage, criterion, generic, matches, result)
 294
 295 #else
 296
 297 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
 298   (result)
 299
 300 #endif
 301
 302
 303 bool
 304 should_emit_struct_debug (tree type, enum debug_info_usage usage)
 305 {
 306   enum debug_struct_file criterion;
 307   tree type_decl;
 308   bool generic = lang_hooks.types.generic_p (type);
 309
 310   if (generic)
 311     criterion = debug_struct_generic[usage];
 312   else
 313     criterion = debug_struct_ordinary[usage];
 314
 315   if (criterion == DINFO_STRUCT_FILE_NONE)
 316     return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
 317   if (criterion == DINFO_STRUCT_FILE_ANY)
 318     return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
 319
 320   type_decl = TYPE_STUB_DECL (type);
 321
 322   if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl))
 323     return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
 324
 325   if (matches_main_base (DECL_SOURCE_FILE (type_decl)))
 326     return DUMP_GSTRUCT (type, usage, criterion, generic, true, true);
 327   return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
 328 }
 329
 330 /* Nonzero means use GNU-only extensions in the generated symbolic
 331    debugging information.  Currently, this only has an effect when
 332    write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG.  */
 333 bool use_gnu_debug_info_extensions;
 334
 335 /* The default visibility for all symbols (unless overridden) */
 336 enum symbol_visibility default_visibility = VISIBILITY_DEFAULT;
 337
 338 /* Global visibility options.  */
 339 struct visibility_flags visibility_options;
 340
 341 /* What to print when a switch has no documentation.  */
 342 static const char undocumented_msg[] = N_("This switch lacks documentation");
 343
 344 /* Used for bookkeeping on whether user set these flags so
 345    -fprofile-use/-fprofile-generate does not use them.  */
 346 static bool profile_arc_flag_set, flag_profile_values_set;
 347 static bool flag_unroll_loops_set, flag_tracer_set;
 348 static bool flag_value_profile_transformations_set;
 349 static bool flag_peel_loops_set, flag_branch_probabilities_set;
 350 static bool flag_inline_functions_set, flag_ipa_cp_set, flag_ipa_cp_clone_set;
 351 static bool flag_predictive_commoning_set, flag_unswitch_loops_set, flag_gcse_after_reload_set;
 352
 353 /* Functions excluded from profiling.  */
 354
 355 typedef char *char_p; /* For DEF_VEC_P.  */
 356 DEF_VEC_P(char_p);
 357 DEF_VEC_ALLOC_P(char_p,heap);
 358
 359 static VEC(char_p,heap) *flag_instrument_functions_exclude_functions;
 360 static VEC(char_p,heap) *flag_instrument_functions_exclude_files;
 361
 362 typedef const char *const_char_p; /* For DEF_VEC_P.  */
 363 DEF_VEC_P(const_char_p);
 364 DEF_VEC_ALLOC_P(const_char_p,heap);
 365
 366 static VEC(const_char_p,heap) *ignored_options;
 367
 368 /* Language specific warning pass for unused results.  */
 369 bool flag_warn_unused_result = false;
 370
 371 /* Input file names.  */
 372 const char **in_fnames;
 373 unsigned num_in_fnames;
 374
 375 static bool common_handle_option (size_t scode, const char *arg, int value,
 376                                   unsigned int lang_mask, int kind,
 377                                   const struct cl_option_handlers *handlers);
 378 static void handle_param (const char *);
 379 static char *write_langs (unsigned int lang_mask);
 380 static void complain_wrong_lang (const char *, const struct cl_option *,
 381                                  unsigned int lang_mask);
 382 static void set_debug_level (enum debug_info_type type, int extended,
 383                              const char *arg);
 384
 385 /* Return a malloced slash-separated list of languages in MASK.  */
 386 static char *
 387 write_langs (unsigned int mask)
 388 {
 389   unsigned int n = 0, len = 0;
 390   const char *lang_name;
 391   char *result;
 392
 393   for (n = 0; (lang_name = lang_names[n]) != 0; n++)
 394     if (mask & (1U << n))
 395       len += strlen (lang_name) + 1;
 396
 397   result = XNEWVEC (char, len);
 398   len = 0;
 399   for (n = 0; (lang_name = lang_names[n]) != 0; n++)
 400     if (mask & (1U << n))
 401       {
 402         if (len)
 403           result[len++] = '/';
 404         strcpy (result + len, lang_name);
 405         len += strlen (lang_name);
 406       }
 407
 408   result[len] = 0;
 409
 410   return result;
 411 }
 412
 413 /* Complain that switch OPT_INDEX does not apply to this front end.  */
 414 static void
 415 complain_wrong_lang (const char *text, const struct cl_option *option,
 416                      unsigned int lang_mask)
 417 {
 418   char *ok_langs, *bad_lang;
 419
 420   if (!lang_hooks.complain_wrong_lang_p (option))
 421     return;
 422
 423   ok_langs = write_langs (option->flags);
 424   bad_lang = write_langs (lang_mask);
 425
 426   /* Eventually this should become a hard error IMO.  */
 427   warning (0, "command line option \"%s\" is valid for %s but not for %s",
 428            text, ok_langs, bad_lang);
 429
 430   free (ok_langs);
 431   free (bad_lang);
 432 }
 433
 434 /* Buffer the unknown option described by the string OPT.  Currently,
 435    we only complain about unknown -Wno-* options if they may have
 436    prevented a diagnostic. Otherwise, we just ignore them.
 437    Note that if we do complain, it is only as a warning, not an error;
 438    passing the compiler an unrecognised -Wno-* option should never
 439    change whether the compilation succeeds or fails.  */
 440
 441 static void postpone_unknown_option_warning(const char *opt)
 442 {
 443   VEC_safe_push (const_char_p, heap, ignored_options, opt);
 444 }
 445
 446 /* Produce a warning for each option previously buffered.  */
 447
 448 void print_ignored_options (void)
 449 {
 450   location_t saved_loc = input_location;
 451
 452   input_location = 0;
 453
 454   while (!VEC_empty (const_char_p, ignored_options))
 455     {
 456       const char *opt;
 457       opt = VEC_pop (const_char_p, ignored_options);
 458       warning (0, "unrecognized command line option \"%s\"", opt);
 459     }
 460
 461   input_location = saved_loc;
 462 }
 463
 464 /* Handle an unknown option ARG, returning true if an error should be
 465    given.  */
 466
 467 static bool
 468 unknown_option_callback (const char *opt)
 469 {
 470   if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
 471     {
 472       /* We don't generate warnings for unknown -Wno-* options unless
 473          we issue diagnostics.  */
 474       postpone_unknown_option_warning (opt);
 475       return false;
 476     }
 477   else
 478     return true;
 479 }
 480
 481 /* Note that an option (index OPT_INDEX, argument ARG, value VALUE)
 482    has been successfully handled with a handler for mask MASK.  */
 483
 484 static void
 485 post_handling_callback (size_t opt_index ATTRIBUTE_UNUSED,
 486                         const char *arg ATTRIBUTE_UNUSED,
 487                         int value ATTRIBUTE_UNUSED,
 488                         unsigned int mask ATTRIBUTE_UNUSED)
 489 {
 490 #ifdef ENABLE_LTO
 491   lto_register_user_option (opt_index, arg, value, mask);
 492 #endif
 493 }
 494
 495 /* Handle a front-end option; arguments and return value as for
 496    handle_option.  */
 497
 498 static bool
 499 lang_handle_option (size_t opt_index, const char *arg, int value,
 500                     unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
 501                     const struct cl_option_handlers *handlers)
 502 {
 503   return lang_hooks.handle_option (opt_index, arg, value, kind, handlers);
 504 }
 505
 506 /* Handle a back-end option; arguments and return value as for
 507    handle_option.  */
 508
 509 static bool
 510 target_handle_option (size_t opt_index, const char *arg, int value,
 511                     unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
 512                     const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
 513 {
 514   gcc_assert (kind == DK_UNSPECIFIED);
 515   return targetm.handle_option (opt_index, arg, value);
 516 }
 517
 518 /* Handle FILENAME from the command line.  */
 519 static void
 520 add_input_filename (const char *filename)
 521 {
 522   num_in_fnames++;
 523   in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
 524   in_fnames[num_in_fnames - 1] = filename;
 525 }
 526
 527 /* Add comma-separated strings to a char_p vector.  */
 528
 529 static void
 530 add_comma_separated_to_vector (VEC(char_p,heap) **pvec, const char* arg)
 531 {
 532   char *tmp;
 533   char *r;
 534   char *w;
 535   char *token_start;
 536
 537   /* We never free this string.  */
 538   tmp = xstrdup (arg);
 539
 540   r = tmp;
 541   w = tmp;
 542   token_start = tmp;
 543
 544   while (*r != '\0')
 545     {
 546       if (*r == ',')
 547         {
 548           *w++ = '\0';
 549           ++r;
 550           VEC_safe_push (char_p, heap, *pvec, token_start);
 551           token_start = w;
 552         }
 553       if (*r == '\\' && r[1] == ',')
 554         {
 555           *w++ = ',';
 556           r += 2;
 557         }
 558       else
 559         *w++ = *r++;
 560     }
 561   if (*token_start != '\0')
 562     VEC_safe_push (char_p, heap, *pvec, token_start);
 563 }
 564
 565 /* Return whether we should exclude FNDECL from instrumentation.  */
 566
 567 bool
 568 flag_instrument_functions_exclude_p (tree fndecl)
 569 {
 570   if (VEC_length (char_p, flag_instrument_functions_exclude_functions) > 0)
 571     {
 572       const char *name;
 573       int i;
 574       char *s;
 575
 576       name = lang_hooks.decl_printable_name (fndecl, 0);
 577       for (i = 0;
 578            VEC_iterate (char_p, flag_instrument_functions_exclude_functions,
 579                         i, s);
 580            ++i)
 581         {
 582           if (strstr (name, s) != NULL)
 583             return true;
 584         }
 585     }
 586
 587   if (VEC_length (char_p, flag_instrument_functions_exclude_files) > 0)
 588     {
 589       const char *name;
 590       int i;
 591       char *s;
 592
 593       name = DECL_SOURCE_FILE (fndecl);
 594       for (i = 0;
 595            VEC_iterate (char_p, flag_instrument_functions_exclude_files, i, s);
 596            ++i)
 597         {
 598           if (strstr (name, s) != NULL)
 599             return true;
 600         }
 601     }
 602
 603   return false;
 604 }
 605
 606
 607 /* Handle the vector of command line options.  LANG_MASK
 608    contains has a single bit set representing the current
 609    language.  HANDLERS describes what functions to call for the options.  */
 610 static void
 611 read_cmdline_options (struct cl_decoded_option *decoded_options,
 612                       unsigned int decoded_options_count,
 613                       unsigned int lang_mask,
 614                       const struct cl_option_handlers *handlers)
 615 {
 616   unsigned int i;
 617
 618   for (i = 1; i < decoded_options_count; i++)
 619     {
 620       if (decoded_options[i].opt_index == OPT_SPECIAL_input_file)
 621         {
 622           if (main_input_filename == NULL)
 623             {
 624               main_input_filename = decoded_options[i].arg;
 625               main_input_baselength
 626                 = base_of_path (main_input_filename, &main_input_basename);
 627             }
 628           add_input_filename (decoded_options[i].arg);
 629           continue;
 630         }
 631
 632       read_cmdline_option (decoded_options + i, lang_mask, handlers);
 633     }
 634 }
 635
 636 /* Parse command line options and set default flag values.  Do minimal
 637    options processing.  The decoded options are placed in *DECODED_OPTIONS
 638    and *DECODED_OPTIONS_COUNT.  */
 639 void
 640 decode_options (unsigned int argc, const char **argv,
 641                 struct cl_decoded_option **decoded_options,
 642                 unsigned int *decoded_options_count)
 643 {
 644   static bool first_time_p = true;
 645   static int initial_min_crossjump_insns;
 646   static int initial_max_fields_for_field_sensitive;
 647   static int initial_loop_invariant_max_bbs_in_loop;
 648   static unsigned int initial_lang_mask;
 649   struct cl_option_handlers handlers;
 650
 651   unsigned int i, lang_mask;
 652   int opt1;
 653   int opt2;
 654   int opt3;
 655   int opt1_max;
 656   int ofast = 0;
 657
 658   if (first_time_p)
 659     {
 660       /* Perform language-specific options initialization.  */
 661       initial_lang_mask = lang_mask = lang_hooks.option_lang_mask ();
 662
 663       lang_hooks.initialize_diagnostics (global_dc);
 664
 665       /* Save initial values of parameters we reset.  */
 666       initial_min_crossjump_insns
 667         = compiler_params[PARAM_MIN_CROSSJUMP_INSNS].value;
 668       initial_max_fields_for_field_sensitive
 669         = compiler_params[PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE].value;
 670       initial_loop_invariant_max_bbs_in_loop
 671         = compiler_params[PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP].value;
 672     }
 673   else
 674     lang_mask = initial_lang_mask;
 675
 676   decode_cmdline_options_to_array (argc, argv, lang_mask,
 677                                    decoded_options, decoded_options_count);
 678   if (first_time_p)
 679     /* Perform language-specific options initialization.  */
 680     lang_hooks.init_options (*decoded_options_count, *decoded_options);
 681
 682   handlers.unknown_option_callback = unknown_option_callback;
 683   handlers.wrong_lang_callback = complain_wrong_lang;
 684   handlers.post_handling_callback = post_handling_callback;
 685   handlers.num_handlers = 3;
 686   handlers.handlers[0].handler = lang_handle_option;
 687   handlers.handlers[0].mask = lang_mask;
 688   handlers.handlers[1].handler = common_handle_option;
 689   handlers.handlers[1].mask = CL_COMMON;
 690   handlers.handlers[2].handler = target_handle_option;
 691   handlers.handlers[2].mask = CL_TARGET;
 692
 693   /* Scan to see what optimization level has been specified.  That will
 694      determine the default value of many flags.  */
 695   for (i = 1; i < *decoded_options_count; i++)
 696     {
 697       struct cl_decoded_option *opt = &(*decoded_options)[i];
 698       switch (opt->opt_index)
 699         {
 700         case OPT_O:
 701           if (*opt->arg == '\0')
 702             {
 703               optimize = 1;
 704               optimize_size = 0;
 705               ofast = 0;
 706             }
 707           else
 708             {
 709               const int optimize_val = integral_argument (opt->arg);
 710               if (optimize_val == -1)
 711                 error ("argument to %qs should be a non-negative integer",
 712                        "-O");
 713               else
 714                 {
 715                   optimize = optimize_val;
 716                   if ((unsigned int) optimize > 255)
 717                     optimize = 255;
 718                   optimize_size = 0;
 719                   ofast = 0;
 720                 }
 721             }
 722           break;
 723
 724         case OPT_Os:
 725           optimize_size = 1;
 726
 727           /* Optimizing for size forces optimize to be 2.  */
 728           optimize = 2;
 729           ofast = 0;
 730           break;
 731
 732         case OPT_Ofast:
 733           /* -Ofast only adds flags to -O3.  */
 734           optimize_size = 0;
 735           optimize = 3;
 736           ofast = 1;
 737           break;
 738
 739         default:
 740           /* Ignore other options in this prescan.  */
 741           break;
 742         }
 743     }
 744
 745   /* Use priority coloring if cover classes is not defined for the
 746      target.  */
 747   if (targetm.ira_cover_classes == NULL)
 748     flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
 749
 750   /* -O1 optimizations.  */
 751   opt1 = (optimize >= 1);
 752   flag_defer_pop = opt1;
 753 #ifdef DELAY_SLOTS
 754   flag_delayed_branch = opt1;
 755 #endif
 756 #ifdef CAN_DEBUG_WITHOUT_FP
 757   flag_omit_frame_pointer = opt1;
 758 #endif
 759   flag_guess_branch_prob = opt1;
 760   flag_cprop_registers = opt1;
 761   flag_forward_propagate = opt1;
 762   flag_if_conversion = opt1;
 763   flag_if_conversion2 = opt1;
 764   flag_ipa_pure_const = opt1;
 765   flag_ipa_reference = opt1;
 766   flag_ipa_profile = opt1;
 767   flag_merge_constants = opt1;
 768   flag_split_wide_types = opt1;
 769   flag_tree_ccp = opt1;
 770   flag_tree_dce = opt1;
 771   flag_tree_dom = opt1;
 772   flag_tree_dse = opt1;
 773   flag_tree_ter = opt1;
 774   flag_tree_sra = opt1;
 775   flag_tree_copyrename = opt1;
 776   flag_tree_fre = opt1;
 777   flag_tree_copy_prop = opt1;
 778   flag_tree_sink = opt1;
 779   flag_tree_ch = opt1;
 780
 781   /* -O2 optimizations.  */
 782   opt2 = (optimize >= 2);
 783   flag_inline_small_functions = opt2;
 784   flag_indirect_inlining = opt2;
 785   flag_partial_inlining = opt2;
 786   flag_thread_jumps = opt2;
 787   flag_crossjumping = opt2;
 788   flag_optimize_sibling_calls = opt2;
 789   flag_cse_follow_jumps = opt2;
 790   flag_gcse = opt2;
 791   flag_expensive_optimizations = opt2;
 792   flag_rerun_cse_after_loop = opt2;
 793   flag_caller_saves = opt2;
 794   flag_peephole2 = opt2;
 795 #ifdef INSN_SCHEDULING
 796   /* Only run the pre-regalloc scheduling pass if optimizing for speed.  */
 797   flag_schedule_insns = opt2 && ! optimize_size;
 798   flag_schedule_insns_after_reload = opt2;
 799 #endif
 800   flag_regmove = opt2;
 801   flag_strict_aliasing = opt2;
 802   flag_strict_overflow = opt2;
 803   flag_reorder_blocks = opt2;
 804   flag_reorder_functions = opt2;
 805   flag_tree_vrp = opt2;
 806   flag_tree_builtin_call_dce = opt2;
 807   flag_tree_pre = opt2;
 808   flag_tree_switch_conversion = opt2;
 809   flag_ipa_cp = opt2;
 810   flag_ipa_sra = opt2;
 811
 812   /* Track fields in field-sensitive alias analysis.  */
 813   set_param_value ("max-fields-for-field-sensitive",
 814                    (opt2) ? 100 : initial_max_fields_for_field_sensitive);
 815
 816   /* For -O1 only do loop invariant motion for very small loops.  */
 817   set_param_value ("loop-invariant-max-bbs-in-loop",
 818                    (opt2) ? initial_loop_invariant_max_bbs_in_loop : 1000);
 819
 820   /* -O3 optimizations.  */
 821   opt3 = (optimize >= 3);
 822   flag_tree_loop_distribute_patterns = opt3;
 823   flag_predictive_commoning = opt3;
 824   flag_inline_functions = opt3;
 825   flag_unswitch_loops = opt3;
 826   flag_gcse_after_reload = opt3;
 827   flag_tree_vectorize = opt3;
 828   flag_ipa_cp_clone = opt3;
 829   if (flag_ipa_cp_clone)
 830     flag_ipa_cp = 1;
 831
 832   /* Just -O1/-O0 optimizations.  */
 833   opt1_max = (optimize <= 1);
 834   align_loops = opt1_max;
 835   align_jumps = opt1_max;
 836   align_labels = opt1_max;
 837   align_functions = opt1_max;
 838
 839   if (optimize_size)
 840     {
 841       /* Inlining of functions reducing size is a good idea regardless of them
 842          being declared inline.  */
 843       flag_inline_functions = 1;
 844
 845       /* Basic optimization options.  */
 846       optimize_size = 1;
 847       if (optimize > 2)
 848         optimize = 2;
 849
 850       /* We want to crossjump as much as possible.  */
 851       set_param_value ("min-crossjump-insns", 1);
 852     }
 853   else
 854     set_param_value ("min-crossjump-insns", initial_min_crossjump_insns);
 855
 856   /* -Ofast adds optimizations to -O3.  */
 857   if (ofast)
 858     {
 859       /* Which is -ffast-math for now.  */
 860       set_fast_math_flags (1);
 861       /* Allow targets to enable extra options with -Ofast
 862          before general options processing so disabling them
 863          again afterwards works.  */
 864       targetm.handle_ofast ();
 865     }
 866
 867   /* Enable -Werror=coverage-mismatch by default */
 868   enable_warning_as_error ("coverage-mismatch", 1, lang_mask, &handlers);
 869
 870   if (first_time_p)
 871     {
 872       /* Initialize whether `char' is signed.  */
 873       flag_signed_char = DEFAULT_SIGNED_CHAR;
 874       /* Set this to a special "uninitialized" value.  The actual default is
 875          set after target options have been processed.  */
 876       flag_short_enums = 2;
 877
 878       /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
 879          modify it.  */
 880       target_flags = targetm.default_target_flags;
 881
 882       /* Some targets have ABI-specified unwind tables.  */
 883       flag_unwind_tables = targetm.unwind_tables_default;
 884     }
 885
 886 #ifdef ENABLE_LTO
 887   /* Clear any options currently held for LTO.  */
 888   lto_clear_user_options ();
 889 #endif
 890
 891 #ifdef OPTIMIZATION_OPTIONS
 892   /* Allow default optimizations to be specified on a per-machine basis.  */
 893   OPTIMIZATION_OPTIONS (optimize, optimize_size);
 894 #endif
 895
 896   read_cmdline_options (*decoded_options, *decoded_options_count, lang_mask,
 897                         &handlers);
 898
 899   if (dump_base_name && ! IS_ABSOLUTE_PATH (dump_base_name))
 900     {
 901       /* First try to make DUMP_BASE_NAME relative to the DUMP_DIR_NAME
 902          directory.  Then try to make DUMP_BASE_NAME relative to the
 903          AUX_BASE_NAME directory, typically the directory to contain
 904          the object file.  */
 905       if (dump_dir_name)
 906         dump_base_name = concat (dump_dir_name, dump_base_name, NULL);
 907       else if (aux_base_name)
 908         {
 909           const char *aux_base;
 910
 911           base_of_path (aux_base_name, &aux_base);
 912           if (aux_base_name != aux_base)
 913             {
 914               int dir_len = aux_base - aux_base_name;
 915               char *new_dump_base_name =
 916                 XNEWVEC (char, strlen(dump_base_name) + dir_len + 1);
 917
 918               /* Copy directory component from AUX_BASE_NAME.  */
 919               memcpy (new_dump_base_name, aux_base_name, dir_len);
 920               /* Append existing DUMP_BASE_NAME.  */
 921               strcpy (new_dump_base_name + dir_len, dump_base_name);
 922               dump_base_name = new_dump_base_name;
 923             }
 924         }
 925     }
 926
 927   /* Handle related options for unit-at-a-time, toplevel-reorder, and
 928      section-anchors.  */
 929   if (!flag_unit_at_a_time)
 930     {
 931       if (flag_section_anchors == 1)
 932         error ("Section anchors must be disabled when unit-at-a-time "
 933                "is disabled.");
 934       flag_section_anchors = 0;
 935       if (flag_toplevel_reorder == 1)
 936         error ("Toplevel reorder must be disabled when unit-at-a-time "
 937                "is disabled.");
 938       flag_toplevel_reorder = 0;
 939     }
 940
 941   /* -Wmissing-noreturn is alias for -Wsuggest-attribute=noreturn.  */
 942   if (warn_missing_noreturn)
 943     warn_suggest_attribute_noreturn = true;
 944
 945   /* Unless the user has asked for section anchors, we disable toplevel
 946      reordering at -O0 to disable transformations that might be surprising
 947      to end users and to get -fno-toplevel-reorder tested.  */
 948   if (!optimize && flag_toplevel_reorder == 2 && flag_section_anchors != 1)
 949     {
 950       flag_toplevel_reorder = 0;
 951       flag_section_anchors = 0;
 952     }
 953   if (!flag_toplevel_reorder)
 954     {
 955       if (flag_section_anchors == 1)
 956         error ("section anchors must be disabled when toplevel reorder"
 957                " is disabled");
 958       flag_section_anchors = 0;
 959     }
 960
 961   if (first_time_p)
 962     {
 963       if (flag_pie)
 964         flag_pic = flag_pie;
 965       if (flag_pic && !flag_pie)
 966         flag_shlib = 1;
 967       first_time_p = false;
 968     }
 969
 970   if (optimize == 0)
 971     {
 972       /* Inlining does not work if not optimizing,
 973          so force it not to be done.  */
 974       warn_inline = 0;
 975       flag_no_inline = 1;
 976     }
 977
 978   /* The optimization to partition hot and cold basic blocks into separate
 979      sections of the .o and executable files does not work (currently)
 980      with exception handling.  This is because there is no support for
 981      generating unwind info.  If flag_exceptions is turned on we need to
 982      turn off the partitioning optimization.  */
 983
 984   if (flag_exceptions && flag_reorder_blocks_and_partition
 985       && (USING_SJLJ_EXCEPTIONS
 986 #ifdef TARGET_UNWIND_INFO
 987           || 1
 988 #endif
 989          ))
 990     {
 991       inform (input_location,
 992               "-freorder-blocks-and-partition does not work with exceptions on this architecture");
 993       flag_reorder_blocks_and_partition = 0;
 994       flag_reorder_blocks = 1;
 995     }
 996
 997   /* If user requested unwind info, then turn off the partitioning
 998      optimization.  */
 999
1000   if (flag_unwind_tables && ! targetm.unwind_tables_default
1001       && flag_reorder_blocks_and_partition
1002       && (USING_SJLJ_EXCEPTIONS
1003 #ifdef TARGET_UNWIND_INFO
1004           || 1
1005 #endif
1006          ))
1007     {
1008       inform (input_location,
1009               "-freorder-blocks-and-partition does not support unwind info on this architecture");
1010       flag_reorder_blocks_and_partition = 0;
1011       flag_reorder_blocks = 1;
1012     }
1013
1014   /* If the target requested unwind info, then turn off the partitioning
1015      optimization with a different message.  Likewise, if the target does not
1016      support named sections.  */
1017
1018   if (flag_reorder_blocks_and_partition
1019       && (!targetm.have_named_sections
1020           || (flag_unwind_tables && targetm.unwind_tables_default
1021               && (USING_SJLJ_EXCEPTIONS
1022 #ifdef TARGET_UNWIND_INFO
1023                   || 1
1024 #endif
1025                  ))))
1026     {
1027       inform (input_location,
1028               "-freorder-blocks-and-partition does not work on this architecture");
1029       flag_reorder_blocks_and_partition = 0;
1030       flag_reorder_blocks = 1;
1031     }
1032
1033   /* Pipelining of outer loops is only possible when general pipelining
1034      capabilities are requested.  */
1035   if (!flag_sel_sched_pipelining)
1036     flag_sel_sched_pipelining_outer_loops = 0;
1037
1038   if (!targetm.ira_cover_classes
1039       && flag_ira_algorithm == IRA_ALGORITHM_CB)
1040     {
1041       inform (input_location,
1042               "-fira-algorithm=CB does not work on this architecture");
1043       flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1044     }
1045
1046   if (flag_conserve_stack)
1047     {
1048       if (!PARAM_SET_P (PARAM_LARGE_STACK_FRAME))
1049         PARAM_VALUE (PARAM_LARGE_STACK_FRAME) = 100;
1050       if (!PARAM_SET_P (PARAM_STACK_FRAME_GROWTH))
1051         PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) = 40;
1052     }
1053   if (flag_wpa || flag_ltrans)
1054     {
1055       /* These passes are not WHOPR compatible yet.  */
1056       flag_ipa_pta = 0;
1057       flag_ipa_struct_reorg = 0;
1058     }
1059
1060   if (flag_lto || flag_whopr)
1061     {
1062 #ifdef ENABLE_LTO
1063       flag_generate_lto = 1;
1064
1065       /* When generating IL, do not operate in whole-program mode.
1066          Otherwise, symbols will be privatized too early, causing link
1067          errors later.  */
1068       flag_whole_program = 0;
1069 #else
1070       error ("LTO support has not been enabled in this configuration");
1071 #endif
1072     }
1073
1074   /* Reconcile -flto and -fwhopr.  Set additional flags as appropriate and
1075      check option consistency.  */
1076   if (flag_lto && flag_whopr)
1077     error ("-flto and -fwhopr are mutually exclusive");
1078 }
1079
1080 #define LEFT_COLUMN     27
1081
1082 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1083    followed by word-wrapped HELP in a second column.  */
1084 static void
1085 wrap_help (const char *help,
1086            const char *item,
1087            unsigned int item_width,
1088            unsigned int columns)
1089 {
1090   unsigned int col_width = LEFT_COLUMN;
1091   unsigned int remaining, room, len;
1092
1093   remaining = strlen (help);
1094
1095   do
1096     {
1097       room = columns - 3 - MAX (col_width, item_width);
1098       if (room > columns)
1099         room = 0;
1100       len = remaining;
1101
1102       if (room < len)
1103         {
1104           unsigned int i;
1105
1106           for (i = 0; help[i]; i++)
1107             {
1108               if (i >= room && len != remaining)
1109                 break;
1110               if (help[i] == ' ')
1111                 len = i;
1112               else if ((help[i] == '-' || help[i] == '/')
1113                        && help[i + 1] != ' '
1114                        && i > 0 && ISALPHA (help[i - 1]))
1115                 len = i + 1;
1116             }
1117         }
1118
1119       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1120       item_width = 0;
1121       while (help[len] == ' ')
1122         len++;
1123       help += len;
1124       remaining -= len;
1125     }
1126   while (remaining);
1127 }
1128
1129 /* Print help for a specific front-end, etc.  */
1130 static void
1131 print_filtered_help (unsigned int include_flags,
1132                      unsigned int exclude_flags,
1133                      unsigned int any_flags,
1134                      unsigned int columns)
1135 {
1136   unsigned int i;
1137   const char *help;
1138   static char *printed = NULL;
1139   bool found = false;
1140   bool displayed = false;
1141
1142   if (include_flags == CL_PARAMS)
1143     {
1144       for (i = 0; i < LAST_PARAM; i++)
1145         {
1146           const char *param = compiler_params[i].option;
1147
1148           help = compiler_params[i].help;
1149           if (help == NULL || *help == '\0')
1150             {
1151               if (exclude_flags & CL_UNDOCUMENTED)
1152                 continue;
1153               help = undocumented_msg;
1154             }
1155
1156           /* Get the translation.  */
1157           help = _(help);
1158
1159           wrap_help (help, param, strlen (param), columns);
1160         }
1161       putchar ('\n');
1162       return;
1163     }
1164
1165   if (!printed)
1166     printed = XCNEWVAR (char, cl_options_count);
1167
1168   for (i = 0; i < cl_options_count; i++)
1169     {
1170       static char new_help[128];
1171       const struct cl_option *option = cl_options + i;
1172       unsigned int len;
1173       const char *opt;
1174       const char *tab;
1175
1176       if (include_flags == 0
1177           || ((option->flags & include_flags) != include_flags))
1178         {
1179           if ((option->flags & any_flags) == 0)
1180             continue;
1181         }
1182
1183       /* Skip unwanted switches.  */
1184       if ((option->flags & exclude_flags) != 0)
1185         continue;
1186
1187       found = true;
1188       /* Skip switches that have already been printed.  */
1189       if (printed[i])
1190         continue;
1191
1192       printed[i] = true;
1193
1194       help = option->help;
1195       if (help == NULL)
1196         {
1197           if (exclude_flags & CL_UNDOCUMENTED)
1198             continue;
1199           help = undocumented_msg;
1200         }
1201
1202       /* Get the translation.  */
1203       help = _(help);
1204
1205       /* Find the gap between the name of the
1206          option and its descriptive text.  */
1207       tab = strchr (help, '\t');
1208       if (tab)
1209         {
1210           len = tab - help;
1211           opt = help;
1212           help = tab + 1;
1213         }
1214       else
1215         {
1216           opt = option->opt_text;
1217           len = strlen (opt);
1218         }
1219
1220       /* With the -Q option enabled we change the descriptive text associated
1221          with an option to be an indication of its current setting.  */
1222       if (!quiet_flag)
1223         {
1224           if (len < (LEFT_COLUMN + 2))
1225             strcpy (new_help, "\t\t");
1226           else
1227             strcpy (new_help, "\t");
1228
1229           if (option->flag_var != NULL)
1230             {
1231               if (option->flags & CL_JOINED)
1232                 {
1233                   if (option->var_type == CLVC_STRING)
1234                     {
1235                       if (* (const char **) option->flag_var != NULL)
1236                         snprintf (new_help + strlen (new_help),
1237                                   sizeof (new_help) - strlen (new_help),
1238                                   * (const char **) option->flag_var);
1239                     }
1240                   else
1241                     sprintf (new_help + strlen (new_help),
1242                              "%#x", * (int *) option->flag_var);
1243                 }
1244               else
1245                 strcat (new_help, option_enabled (i)
1246                         ? _("[enabled]") : _("[disabled]"));
1247             }
1248
1249           help = new_help;
1250         }
1251
1252       wrap_help (help, opt, len, columns);
1253       displayed = true;
1254     }
1255
1256   if (! found)
1257     {
1258       unsigned int langs = include_flags & CL_LANG_ALL;
1259
1260       if (langs == 0)
1261         printf (_(" No options with the desired characteristics were found\n"));
1262       else
1263         {
1264           unsigned int i;
1265
1266           /* PR 31349: Tell the user how to see all of the
1267              options supported by a specific front end.  */
1268           for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1269             if ((1U << i) & langs)
1270               printf (_(" None found.  Use --help=%s to show *all* the options supported by the %s front-end\n"),
1271                       lang_names[i], lang_names[i]);
1272         }
1273
1274     }
1275   else if (! displayed)
1276     printf (_(" All options with the desired characteristics have already been displayed\n"));
1277
1278   putchar ('\n');
1279 }
1280
1281 /* Display help for a specified type of option.
1282    The options must have ALL of the INCLUDE_FLAGS set
1283    ANY of the flags in the ANY_FLAGS set
1284    and NONE of the EXCLUDE_FLAGS set.  */
1285 static void
1286 print_specific_help (unsigned int include_flags,
1287                      unsigned int exclude_flags,
1288                      unsigned int any_flags)
1289 {
1290   unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1291   const char * description = NULL;
1292   const char * descrip_extra = "";
1293   size_t i;
1294   unsigned int flag;
1295   static unsigned int columns = 0;
1296
1297   /* Sanity check: Make sure that we do not have more
1298      languages than we have bits available to enumerate them.  */
1299   gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
1300
1301   /* If we have not done so already, obtain
1302      the desired maximum width of the output.  */
1303   if (columns == 0)
1304     {
1305       const char *p;
1306
1307       GET_ENVIRONMENT (p, "COLUMNS");
1308       if (p != NULL)
1309         {
1310           int value = atoi (p);
1311
1312           if (value > 0)
1313             columns = value;
1314         }
1315
1316       if (columns == 0)
1317         /* Use a reasonable default.  */
1318         columns = 80;
1319     }
1320
1321   /* Decide upon the title for the options that we are going to display.  */
1322   for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1323     {
1324       switch (flag & include_flags)
1325         {
1326         case 0:
1327           break;
1328
1329         case CL_TARGET:
1330           description = _("The following options are target specific");
1331           break;
1332         case CL_WARNING:
1333           description = _("The following options control compiler warning messages");
1334           break;
1335         case CL_OPTIMIZATION:
1336           description = _("The following options control optimizations");
1337           break;
1338         case CL_COMMON:
1339           description = _("The following options are language-independent");
1340           break;
1341         case CL_PARAMS:
1342           description = _("The --param option recognizes the following as parameters");
1343           break;
1344         default:
1345           if (i >= cl_lang_count)
1346             break;
1347           if (exclude_flags & all_langs_mask)
1348             description = _("The following options are specific to just the language ");
1349           else
1350             description = _("The following options are supported by the language ");
1351           descrip_extra = lang_names [i];
1352           break;
1353         }
1354     }
1355
1356   if (description == NULL)
1357     {
1358       if (any_flags == 0)
1359         {
1360           if (include_flags & CL_UNDOCUMENTED)
1361             description = _("The following options are not documented");
1362           else if (include_flags & CL_SEPARATE)
1363             description = _("The following options take separate arguments");
1364           else if (include_flags & CL_JOINED)
1365             description = _("The following options take joined arguments");
1366           else
1367             {
1368               internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1369                               include_flags);
1370               return;
1371             }
1372         }
1373       else
1374         {
1375           if (any_flags & all_langs_mask)
1376             description = _("The following options are language-related");
1377           else
1378             description = _("The following options are language-independent");
1379         }
1380     }
1381
1382   printf ("%s%s:\n", description, descrip_extra);
1383   print_filtered_help (include_flags, exclude_flags, any_flags, columns);
1384 }
1385
1386 /* Handle target- and language-independent options.  Return zero to
1387    generate an "unknown option" message.  Only options that need
1388    extra handling need to be listed here; if you simply want
1389    VALUE assigned to a variable, it happens automatically.  */
1390
1391 static bool
1392 common_handle_option (size_t scode, const char *arg, int value,
1393                       unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
1394                       const struct cl_option_handlers *handlers)
1395 {
1396   static bool verbose = false;
1397   enum opt_code code = (enum opt_code) scode;
1398
1399   switch (code)
1400     {
1401     case OPT__param:
1402       handle_param (arg);
1403       break;
1404
1405     case OPT_v:
1406       verbose = true;
1407       break;
1408
1409     case OPT_fhelp:
1410     case OPT__help:
1411       {
1412         unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1413         unsigned int undoc_mask;
1414         unsigned int i;
1415
1416         undoc_mask = (verbose | extra_warnings) ? 0 : CL_UNDOCUMENTED;
1417         /* First display any single language specific options.  */
1418         for (i = 0; i < cl_lang_count; i++)
1419           print_specific_help
1420             (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0);
1421         /* Next display any multi language specific options.  */
1422         print_specific_help (0, undoc_mask, all_langs_mask);
1423         /* Then display any remaining, non-language options.  */
1424         for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1425           print_specific_help (i, undoc_mask, 0);
1426         exit_after_options = true;
1427         break;
1428       }
1429
1430     case OPT_ftarget_help:
1431     case OPT__target_help:
1432       print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0);
1433       exit_after_options = true;
1434
1435       /* Allow the target a chance to give the user some additional information.  */
1436       if (targetm.help)
1437         targetm.help ();
1438       break;
1439
1440     case OPT_fhelp_:
1441     case OPT__help_:
1442       {
1443         const char * a = arg;
1444         unsigned int include_flags = 0;
1445         /* Note - by default we include undocumented options when listing
1446            specific classes.  If you only want to see documented options
1447            then add ",^undocumented" to the --help= option.  E.g.:
1448
1449            --help=target,^undocumented  */
1450         unsigned int exclude_flags = 0;
1451
1452         /* Walk along the argument string, parsing each word in turn.
1453            The format is:
1454            arg = [^]{word}[,{arg}]
1455            word = {optimizers|target|warnings|undocumented|
1456                    params|common|<language>}  */
1457         while (* a != 0)
1458           {
1459             static struct
1460             {
1461               const char * string;
1462               unsigned int flag;
1463             }
1464             specifics[] =
1465             {
1466               { "optimizers", CL_OPTIMIZATION },
1467               { "target", CL_TARGET },
1468               { "warnings", CL_WARNING },
1469               { "undocumented", CL_UNDOCUMENTED },
1470               { "params", CL_PARAMS },
1471               { "joined", CL_JOINED },
1472               { "separate", CL_SEPARATE },
1473               { "common", CL_COMMON },
1474               { NULL, 0 }
1475             };
1476             unsigned int * pflags;
1477             const char * comma;
1478             unsigned int lang_flag, specific_flag;
1479             unsigned int len;
1480             unsigned int i;
1481
1482             if (* a == '^')
1483               {
1484                 ++ a;
1485                 pflags = & exclude_flags;
1486               }
1487             else
1488               pflags = & include_flags;
1489
1490             comma = strchr (a, ',');
1491             if (comma == NULL)
1492               len = strlen (a);
1493             else
1494               len = comma - a;
1495             if (len == 0)
1496               {
1497                 a = comma + 1;
1498                 continue;
1499               }
1500
1501             /* Check to see if the string matches an option class name.  */
1502             for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1503               if (strncasecmp (a, specifics[i].string, len) == 0)
1504                 {
1505                   specific_flag = specifics[i].flag;
1506                   break;
1507                 }
1508
1509             /* Check to see if the string matches a language name.
1510                Note - we rely upon the alpha-sorted nature of the entries in
1511                the lang_names array, specifically that shorter names appear
1512                before their longer variants.  (i.e. C before C++).  That way
1513                when we are attempting to match --help=c for example we will
1514                match with C first and not C++.  */
1515             for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1516               if (strncasecmp (a, lang_names[i], len) == 0)
1517                 {
1518                   lang_flag = 1U << i;
1519                   break;
1520                 }
1521
1522             if (specific_flag != 0)
1523               {
1524                 if (lang_flag == 0)
1525                   * pflags |= specific_flag;
1526                 else
1527                   {
1528                     /* The option's argument matches both the start of a
1529                        language name and the start of an option class name.
1530                        We have a special case for when the user has
1531                        specified "--help=c", but otherwise we have to issue
1532                        a warning.  */
1533                     if (strncasecmp (a, "c", len) == 0)
1534                       * pflags |= lang_flag;
1535                     else
1536                       fnotice (stderr,
1537                                "warning: --help argument %.*s is ambiguous, please be more specific\n",
1538                                len, a);
1539                   }
1540               }
1541             else if (lang_flag != 0)
1542               * pflags |= lang_flag;
1543             else
1544               fnotice (stderr,
1545                        "warning: unrecognized argument to --help= option: %.*s\n",
1546                        len, a);
1547
1548             if (comma == NULL)
1549               break;
1550             a = comma + 1;
1551           }
1552
1553         if (include_flags)
1554           print_specific_help (include_flags, exclude_flags, 0);
1555         exit_after_options = true;
1556         break;
1557       }
1558
1559     case OPT_fversion:
1560     case OPT__version:
1561       exit_after_options = true;
1562       break;
1563
1564     case OPT_O:
1565     case OPT_Os:
1566     case OPT_Ofast:
1567       /* Currently handled in a prescan.  */
1568       break;
1569
1570     case OPT_Werror_:
1571       enable_warning_as_error (arg, value, lang_mask, handlers);
1572       break;
1573
1574     case OPT_Wlarger_than_:
1575       /* This form corresponds to -Wlarger-than-.
1576          Kept for backward compatibility.
1577          Don't use it as the first argument of warning().  */
1578
1579     case OPT_Wlarger_than_eq:
1580       larger_than_size = value;
1581       warn_larger_than = value != -1;
1582       break;
1583
1584     case OPT_Wfatal_errors:
1585       global_dc->fatal_errors = value;
1586       break;
1587
1588     case OPT_Wframe_larger_than_:
1589       frame_larger_than_size = value;
1590       warn_frame_larger_than = value != -1;
1591       break;
1592
1593     case OPT_Wstrict_aliasing:
1594       set_Wstrict_aliasing (value);
1595       break;
1596
1597     case OPT_Wstrict_aliasing_:
1598       warn_strict_aliasing = value;
1599       break;
1600
1601     case OPT_Wstrict_overflow:
1602       warn_strict_overflow = (value
1603                               ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1604                               : 0);
1605       break;
1606
1607     case OPT_Wstrict_overflow_:
1608       warn_strict_overflow = value;
1609       break;
1610
1611     case OPT_Wsystem_headers:
1612       global_dc->warn_system_headers = value;
1613       break;
1614
1615     case OPT_Wunused:
1616       warn_unused = value;
1617       break;
1618
1619     case OPT_aux_info:
1620     case OPT_aux_info_:
1621       aux_info_file_name = arg;
1622       flag_gen_aux_info = 1;
1623       break;
1624
1625     case OPT_auxbase:
1626       aux_base_name = arg;
1627       break;
1628
1629     case OPT_auxbase_strip:
1630       {
1631         char *tmp = xstrdup (arg);
1632         strip_off_ending (tmp, strlen (tmp));
1633         if (tmp[0])
1634           aux_base_name = tmp;
1635       }
1636       break;
1637
1638     case OPT_d:
1639       decode_d_option (arg);
1640       break;
1641
1642     case OPT_dumpbase:
1643       dump_base_name = arg;
1644       break;
1645
1646     case OPT_dumpdir:
1647       dump_dir_name = arg;
1648       break;
1649
1650     case OPT_falign_functions_:
1651       align_functions = value;
1652       break;
1653
1654     case OPT_falign_jumps_:
1655       align_jumps = value;
1656       break;
1657
1658     case OPT_falign_labels_:
1659       align_labels = value;
1660       break;
1661
1662     case OPT_falign_loops_:
1663       align_loops = value;
1664       break;
1665
1666     case OPT_fbranch_probabilities:
1667       flag_branch_probabilities_set = true;
1668       break;
1669
1670     case OPT_fcall_used_:
1671       fix_register (arg, 0, 1);
1672       break;
1673
1674     case OPT_fcall_saved_:
1675       fix_register (arg, 0, 0);
1676       break;
1677
1678     case OPT_fdbg_cnt_:
1679       dbg_cnt_process_opt (arg);
1680       break;
1681
1682     case OPT_fdbg_cnt_list:
1683       dbg_cnt_list_all_counters ();
1684       break;
1685
1686     case OPT_fdebug_prefix_map_:
1687       add_debug_prefix_map (arg);
1688       break;
1689
1690     case OPT_fdiagnostics_show_location_:
1691       if (!strcmp (arg, "once"))
1692         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
1693       else if (!strcmp (arg, "every-line"))
1694         diagnostic_prefixing_rule (global_dc)
1695           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
1696       else
1697         return false;
1698       break;
1699
1700     case OPT_fdiagnostics_show_option:
1701       global_dc->show_option_requested = value;
1702       break;
1703
1704     case OPT_fdump_:
1705       if (!dump_switch_p (arg))
1706         return false;
1707       break;
1708
1709     case OPT_fexcess_precision_:
1710       if (!strcmp (arg, "fast"))
1711         flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
1712       else if (!strcmp (arg, "standard"))
1713         flag_excess_precision_cmdline = EXCESS_PRECISION_STANDARD;
1714       else
1715         error ("unknown excess precision style \"%s\"", arg);
1716       break;
1717
1718     case OPT_ffast_math:
1719       set_fast_math_flags (value);
1720       break;
1721
1722     case OPT_funsafe_math_optimizations:
1723       set_unsafe_math_optimizations_flags (value);
1724       break;
1725
1726     case OPT_ffixed_:
1727       fix_register (arg, 1, 1);
1728       break;
1729
1730     case OPT_finline_limit_:
1731     case OPT_finline_limit_eq:
1732       set_param_value ("max-inline-insns-single", value / 2);
1733       set_param_value ("max-inline-insns-auto", value / 2);
1734       break;
1735
1736     case OPT_finstrument_functions_exclude_function_list_:
1737       add_comma_separated_to_vector
1738         (&flag_instrument_functions_exclude_functions, arg);
1739       break;
1740
1741     case OPT_finstrument_functions_exclude_file_list_:
1742       add_comma_separated_to_vector
1743         (&flag_instrument_functions_exclude_files, arg);
1744       break;
1745
1746     case OPT_fmessage_length_:
1747       pp_set_line_maximum_length (global_dc->printer, value);
1748       break;
1749
1750     case OPT_fpack_struct_:
1751       if (value <= 0 || (value & (value - 1)) || value > 16)
1752         error ("structure alignment must be a small power of two, not %d", value);
1753       else
1754         {
1755           initial_max_fld_align = value;
1756           maximum_field_alignment = value * BITS_PER_UNIT;
1757         }
1758       break;
1759
1760     case OPT_fpeel_loops:
1761       flag_peel_loops_set = true;
1762       break;
1763
1764     case OPT_fplugin_:
1765 #ifdef ENABLE_PLUGIN
1766       add_new_plugin (arg);
1767 #else
1768       error ("Plugin support is disabled.  Configure with --enable-plugin.");
1769 #endif
1770       break;
1771
1772     case OPT_fplugin_arg_:
1773 #ifdef ENABLE_PLUGIN
1774       parse_plugin_arg_opt (arg);
1775 #else
1776       error ("Plugin support is disabled.  Configure with --enable-plugin.");
1777 #endif
1778       break;
1779
1780     case OPT_fprofile_arcs:
1781       profile_arc_flag_set = true;
1782       break;
1783
1784     case OPT_finline_functions:
1785       flag_inline_functions_set = true;
1786       break;
1787
1788     case OPT_fprofile_dir_:
1789       profile_data_prefix = xstrdup (arg);
1790       break;
1791
1792     case OPT_fprofile_use_:
1793       profile_data_prefix = xstrdup (arg);
1794       flag_profile_use = true;
1795       value = true;
1796       /* No break here - do -fprofile-use processing. */
1797     case OPT_fprofile_use:
1798       if (!flag_branch_probabilities_set)
1799         flag_branch_probabilities = value;
1800       if (!flag_profile_values_set)
1801         flag_profile_values = value;
1802       if (!flag_unroll_loops_set)
1803         flag_unroll_loops = value;
1804       if (!flag_peel_loops_set)
1805         flag_peel_loops = value;
1806       if (!flag_tracer_set)
1807         flag_tracer = value;
1808       if (!flag_value_profile_transformations_set)
1809         flag_value_profile_transformations = value;
1810       if (!flag_inline_functions_set)
1811         flag_inline_functions = value;
1812       if (!flag_ipa_cp_set)
1813         flag_ipa_cp = value;
1814       if (!flag_ipa_cp_clone_set
1815           && value && flag_ipa_cp)
1816         flag_ipa_cp_clone = value;
1817       if (!flag_predictive_commoning_set)
1818         flag_predictive_commoning = value;
1819       if (!flag_unswitch_loops_set)
1820         flag_unswitch_loops = value;
1821       if (!flag_gcse_after_reload_set)
1822         flag_gcse_after_reload = value;
1823       break;
1824
1825     case OPT_fprofile_generate_:
1826       profile_data_prefix = xstrdup (arg);
1827       value = true;
1828       /* No break here - do -fprofile-generate processing. */
1829     case OPT_fprofile_generate:
1830       if (!profile_arc_flag_set)
1831         profile_arc_flag = value;
1832       if (!flag_profile_values_set)
1833         flag_profile_values = value;
1834       if (!flag_value_profile_transformations_set)
1835         flag_value_profile_transformations = value;
1836       if (!flag_inline_functions_set)
1837         flag_inline_functions = value;
1838       break;
1839
1840     case OPT_fprofile_values:
1841       flag_profile_values_set = true;
1842       break;
1843
1844     case OPT_fshow_column:
1845       global_dc->show_column = value;
1846       break;
1847
1848     case OPT_fvisibility_:
1849       {
1850         if (!strcmp(arg, "default"))
1851           default_visibility = VISIBILITY_DEFAULT;
1852         else if (!strcmp(arg, "internal"))
1853           default_visibility = VISIBILITY_INTERNAL;
1854         else if (!strcmp(arg, "hidden"))
1855           default_visibility = VISIBILITY_HIDDEN;
1856         else if (!strcmp(arg, "protected"))
1857           default_visibility = VISIBILITY_PROTECTED;
1858         else
1859           error ("unrecognized visibility value \"%s\"", arg);
1860       }
1861       break;
1862
1863     case OPT_fvpt:
1864       flag_value_profile_transformations_set = true;
1865       break;
1866
1867     case OPT_frandom_seed:
1868       /* The real switch is -fno-random-seed.  */
1869       if (value)
1870         return false;
1871       set_random_seed (NULL);
1872       break;
1873
1874     case OPT_frandom_seed_:
1875       set_random_seed (arg);
1876       break;
1877
1878     case OPT_fselective_scheduling:
1879     case OPT_fselective_scheduling2:
1880       sel_sched_switch_set = true;
1881       break;
1882
1883     case OPT_fsched_verbose_:
1884 #ifdef INSN_SCHEDULING
1885       fix_sched_param ("verbose", arg);
1886       break;
1887 #else
1888       return false;
1889 #endif
1890
1891     case OPT_fsched_stalled_insns_:
1892       flag_sched_stalled_insns = value;
1893       if (flag_sched_stalled_insns == 0)
1894         flag_sched_stalled_insns = -1;
1895       break;
1896
1897     case OPT_fsched_stalled_insns_dep_:
1898       flag_sched_stalled_insns_dep = value;
1899       break;
1900
1901     case OPT_fstack_check_:
1902       if (!strcmp (arg, "no"))
1903         flag_stack_check = NO_STACK_CHECK;
1904       else if (!strcmp (arg, "generic"))
1905         /* This is the old stack checking method.  */
1906         flag_stack_check = STACK_CHECK_BUILTIN
1907                            ? FULL_BUILTIN_STACK_CHECK
1908                            : GENERIC_STACK_CHECK;
1909       else if (!strcmp (arg, "specific"))
1910         /* This is the new stack checking method.  */
1911         flag_stack_check = STACK_CHECK_BUILTIN
1912                            ? FULL_BUILTIN_STACK_CHECK
1913                            : STACK_CHECK_STATIC_BUILTIN
1914                              ? STATIC_BUILTIN_STACK_CHECK
1915                              : GENERIC_STACK_CHECK;
1916       else
1917         warning (0, "unknown stack check parameter \"%s\"", arg);
1918       break;
1919
1920     case OPT_fstack_check:
1921       /* This is the same as the "specific" mode above.  */
1922       if (value)
1923         flag_stack_check = STACK_CHECK_BUILTIN
1924                            ? FULL_BUILTIN_STACK_CHECK
1925                            : STACK_CHECK_STATIC_BUILTIN
1926                              ? STATIC_BUILTIN_STACK_CHECK
1927                              : GENERIC_STACK_CHECK;
1928       else
1929         flag_stack_check = NO_STACK_CHECK;
1930       break;
1931
1932     case OPT_fstack_limit:
1933       /* The real switch is -fno-stack-limit.  */
1934       if (value)
1935         return false;
1936       stack_limit_rtx = NULL_RTX;
1937       break;
1938
1939     case OPT_fstack_limit_register_:
1940       {
1941         int reg = decode_reg_name (arg);
1942         if (reg < 0)
1943           error ("unrecognized register name \"%s\"", arg);
1944         else
1945           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1946       }
1947       break;
1948
1949     case OPT_fstack_limit_symbol_:
1950       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1951       break;
1952
1953     case OPT_ftree_vectorizer_verbose_:
1954       vect_set_verbosity_level (arg);
1955       break;
1956
1957     case OPT_ftls_model_:
1958       if (!strcmp (arg, "global-dynamic"))
1959         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1960       else if (!strcmp (arg, "local-dynamic"))
1961         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1962       else if (!strcmp (arg, "initial-exec"))
1963         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1964       else if (!strcmp (arg, "local-exec"))
1965         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1966       else
1967         warning (0, "unknown tls-model \"%s\"", arg);
1968       break;
1969
1970     case OPT_fira_algorithm_:
1971       if (!strcmp (arg, "CB"))
1972         flag_ira_algorithm = IRA_ALGORITHM_CB;
1973       else if (!strcmp (arg, "priority"))
1974         flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1975       else
1976         warning (0, "unknown ira algorithm \"%s\"", arg);
1977       break;
1978
1979     case OPT_fira_region_:
1980       if (!strcmp (arg, "one"))
1981         flag_ira_region = IRA_REGION_ONE;
1982       else if (!strcmp (arg, "all"))
1983         flag_ira_region = IRA_REGION_ALL;
1984       else if (!strcmp (arg, "mixed"))
1985         flag_ira_region = IRA_REGION_MIXED;
1986       else
1987         warning (0, "unknown ira region \"%s\"", arg);
1988       break;
1989
1990     case OPT_fira_verbose_:
1991       flag_ira_verbose = value;
1992       break;
1993
1994     case OPT_ftracer:
1995       flag_tracer_set = true;
1996       break;
1997
1998     case OPT_fipa_cp:
1999       flag_ipa_cp_set = true;
2000       break;
2001
2002     case OPT_fipa_cp_clone:
2003       flag_ipa_cp_clone_set = true;
2004       break;
2005
2006     case OPT_fpredictive_commoning:
2007       flag_predictive_commoning_set = true;
2008       break;
2009
2010     case OPT_funswitch_loops:
2011       flag_unswitch_loops_set = true;
2012       break;
2013
2014     case OPT_fgcse_after_reload:
2015       flag_gcse_after_reload_set = true;
2016       break;
2017
2018     case OPT_funroll_loops:
2019       flag_unroll_loops_set = true;
2020       break;
2021
2022     case OPT_g:
2023       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
2024       break;
2025
2026     case OPT_gcoff:
2027       set_debug_level (SDB_DEBUG, false, arg);
2028       break;
2029
2030     case OPT_gdwarf_:
2031       if (value < 2 || value > 4)
2032         error ("dwarf version %d is not supported", value);
2033       else
2034         dwarf_version = value;
2035       set_debug_level (DWARF2_DEBUG, false, "");
2036       break;
2037
2038     case OPT_ggdb:
2039       set_debug_level (NO_DEBUG, 2, arg);
2040       break;
2041
2042     case OPT_gstabs:
2043     case OPT_gstabs_:
2044       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
2045       break;
2046
2047     case OPT_gvms:
2048       set_debug_level (VMS_DEBUG, false, arg);
2049       break;
2050
2051     case OPT_gxcoff:
2052     case OPT_gxcoff_:
2053       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
2054       break;
2055
2056     case OPT_o:
2057       asm_file_name = arg;
2058       break;
2059
2060     case OPT_pedantic_errors:
2061       flag_pedantic_errors = pedantic = 1;
2062       global_dc->pedantic_errors = 1;
2063       break;
2064
2065     case OPT_fwhopr:
2066       flag_whopr = value;
2067       break;
2068
2069     case OPT_w:
2070       global_dc->inhibit_warnings = true;
2071       break;
2072
2073     case OPT_fsee:
2074     case OPT_fcse_skip_blocks:
2075     case OPT_floop_optimize:
2076     case OPT_frerun_loop_opt:
2077     case OPT_fsched2_use_traces:
2078     case OPT_fstrength_reduce:
2079     case OPT_ftree_store_copy_prop:
2080     case OPT_fforce_addr:
2081     case OPT_ftree_salias:
2082     case OPT_ftree_store_ccp:
2083     case OPT_Wunreachable_code:
2084     case OPT_fargument_alias:
2085     case OPT_fargument_noalias:
2086     case OPT_fargument_noalias_anything:
2087     case OPT_fargument_noalias_global:
2088       /* These are no-ops, preserved for backward compatibility.  */
2089       break;
2090
2091     case OPT_fuse_linker_plugin:
2092       /* No-op. Used by the driver and passed to us because it starts with f.*/
2093       break;
2094
2095     default:
2096       /* If the flag was handled in a standard way, assume the lack of
2097          processing here is intentional.  */
2098       gcc_assert (cl_options[scode].flag_var);
2099       break;
2100     }
2101
2102   return true;
2103 }
2104
2105 /* Handle --param NAME=VALUE.  */
2106 static void
2107 handle_param (const char *carg)
2108 {
2109   char *equal, *arg;
2110   int value;
2111
2112   arg = xstrdup (carg);
2113   equal = strchr (arg, '=');
2114   if (!equal)
2115     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
2116   else
2117     {
2118       value = integral_argument (equal + 1);
2119       if (value == -1)
2120         error ("invalid --param value %qs", equal + 1);
2121       else
2122         {
2123           *equal = '\0';
2124           set_param_value (arg, value);
2125         }
2126     }
2127
2128   free (arg);
2129 }
2130
2131 /* Used to set the level of strict aliasing warnings,
2132    when no level is specified (i.e., when -Wstrict-aliasing, and not
2133    -Wstrict-aliasing=level was given).
2134    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2135    and 0 otherwise.  After calling this function, wstrict_aliasing will be
2136    set to the default value of -Wstrict_aliasing=level, currently 3.  */
2137 void
2138 set_Wstrict_aliasing (int onoff)
2139 {
2140   gcc_assert (onoff == 0 || onoff == 1);
2141   if (onoff != 0)
2142     warn_strict_aliasing = 3;
2143   else
2144     warn_strict_aliasing = 0;
2145 }
2146
2147 /* The following routines are useful in setting all the flags that
2148    -ffast-math and -fno-fast-math imply.  */
2149 void
2150 set_fast_math_flags (int set)
2151 {
2152   flag_unsafe_math_optimizations = set;
2153   set_unsafe_math_optimizations_flags (set);
2154   flag_finite_math_only = set;
2155   flag_errno_math = !set;
2156   if (set)
2157     {
2158       flag_signaling_nans = 0;
2159       flag_rounding_math = 0;
2160       flag_cx_limited_range = 1;
2161     }
2162 }
2163
2164 /* When -funsafe-math-optimizations is set the following
2165    flags are set as well.  */
2166 void
2167 set_unsafe_math_optimizations_flags (int set)
2168 {
2169   flag_trapping_math = !set;
2170   flag_signed_zeros = !set;
2171   flag_associative_math = set;
2172   flag_reciprocal_math = set;
2173 }
2174
2175 /* Return true iff flags are set as if -ffast-math.  */
2176 bool
2177 fast_math_flags_set_p (void)
2178 {
2179   return (!flag_trapping_math
2180           && flag_unsafe_math_optimizations
2181           && flag_finite_math_only
2182           && !flag_signed_zeros
2183           && !flag_errno_math);
2184 }
2185
2186 /* Return true iff flags are set as if -ffast-math but using the flags stored
2187    in the struct cl_optimization structure.  */
2188 bool
2189 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2190 {
2191   return (!opt->flag_trapping_math
2192           && opt->flag_unsafe_math_optimizations
2193           && opt->flag_finite_math_only
2194           && !opt->flag_signed_zeros
2195           && !opt->flag_errno_math);
2196 }
2197
2198 /* Handle a debug output -g switch.  EXTENDED is true or false to support
2199    extended output (2 is special and means "-ggdb" was given).  */
2200 static void
2201 set_debug_level (enum debug_info_type type, int extended, const char *arg)
2202 {
2203   static bool type_explicit;
2204
2205   use_gnu_debug_info_extensions = extended;
2206
2207   if (type == NO_DEBUG)
2208     {
2209       if (write_symbols == NO_DEBUG)
2210         {
2211           write_symbols = PREFERRED_DEBUGGING_TYPE;
2212
2213           if (extended == 2)
2214             {
2215 #ifdef DWARF2_DEBUGGING_INFO
2216               write_symbols = DWARF2_DEBUG;
2217 #elif defined DBX_DEBUGGING_INFO
2218               write_symbols = DBX_DEBUG;
2219 #endif
2220             }
2221
2222           if (write_symbols == NO_DEBUG)
2223             warning (0, "target system does not support debug output");
2224         }
2225     }
2226   else
2227     {
2228       /* Does it conflict with an already selected type?  */
2229       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
2230         error ("debug format \"%s\" conflicts with prior selection",
2231                debug_type_names[type]);
2232       write_symbols = type;
2233       type_explicit = true;
2234     }
2235
2236   /* A debug flag without a level defaults to level 2.  */
2237   if (*arg == '\0')
2238     {
2239       if (!debug_info_level)
2240         debug_info_level = DINFO_LEVEL_NORMAL;
2241     }
2242   else
2243     {
2244       int argval = integral_argument (arg);
2245       if (argval == -1)
2246         error ("unrecognised debug output level \"%s\"", arg);
2247       else if (argval > 3)
2248         error ("debug output level %s is too high", arg);
2249       else
2250         debug_info_level = (enum debug_info_level) argval;
2251     }
2252 }
2253
2254 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
2255    a simple on-off switch.  */
2256
2257 int
2258 option_enabled (int opt_idx)
2259 {
2260   const struct cl_option *option = &(cl_options[opt_idx]);
2261
2262   if (option->flag_var)
2263     switch (option->var_type)
2264       {
2265       case CLVC_BOOLEAN:
2266         return *(int *) option->flag_var != 0;
2267
2268       case CLVC_EQUAL:
2269         return *(int *) option->flag_var == option->var_value;
2270
2271       case CLVC_BIT_CLEAR:
2272         return (*(int *) option->flag_var & option->var_value) == 0;
2273
2274       case CLVC_BIT_SET:
2275         return (*(int *) option->flag_var & option->var_value) != 0;
2276
2277       case CLVC_STRING:
2278         break;
2279       }
2280   return -1;
2281 }
2282
2283 /* Fill STATE with the current state of option OPTION.  Return true if
2284    there is some state to store.  */
2285
2286 bool
2287 get_option_state (int option, struct cl_option_state *state)
2288 {
2289   if (cl_options[option].flag_var == 0)
2290     return false;
2291
2292   switch (cl_options[option].var_type)
2293     {
2294     case CLVC_BOOLEAN:
2295     case CLVC_EQUAL:
2296       state->data = cl_options[option].flag_var;
2297       state->size = sizeof (int);
2298       break;
2299
2300     case CLVC_BIT_CLEAR:
2301     case CLVC_BIT_SET:
2302       state->ch = option_enabled (option);
2303       state->data = &state->ch;
2304       state->size = 1;
2305       break;
2306
2307     case CLVC_STRING:
2308       state->data = *(const char **) cl_options[option].flag_var;
2309       if (state->data == 0)
2310         state->data = "";
2311       state->size = strlen ((const char *) state->data) + 1;
2312       break;
2313     }
2314   return true;
2315 }
2316
2317 /* Callback function, called when -Werror= enables a warning.  */
2318
2319 static void (*warning_as_error_callback) (int) = NULL;
2320
2321 /* Register a callback for enable_warning_as_error calls.  */
2322
2323 void
2324 register_warning_as_error_callback (void (*callback) (int))
2325 {
2326   gcc_assert (warning_as_error_callback == NULL || callback == NULL);
2327   warning_as_error_callback = callback;
2328 }
2329
2330 /* Enable a warning option as an error.  This is used by -Werror= and
2331    also by legacy Werror-implicit-function-declaration.  */
2332
2333 void
2334 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
2335                          const struct cl_option_handlers *handlers)
2336 {
2337   char *new_option;
2338   int option_index;
2339
2340   new_option = XNEWVEC (char, strlen (arg) + 2);
2341   new_option[0] = 'W';
2342   strcpy (new_option + 1, arg);
2343   option_index = find_opt (new_option, lang_mask);
2344   if (option_index == OPT_SPECIAL_unknown)
2345     {
2346       error ("-Werror=%s: No option -%s", arg, new_option);
2347     }
2348   else
2349     {
2350       const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
2351
2352       diagnostic_classify_diagnostic (global_dc, option_index, kind,
2353                                       UNKNOWN_LOCATION);
2354       if (kind == DK_ERROR)
2355         {
2356           const struct cl_option * const option = cl_options + option_index;
2357
2358           /* -Werror=foo implies -Wfoo.  */
2359           if (option->var_type == CLVC_BOOLEAN)
2360             handle_option (option_index, arg, value, lang_mask, (int)kind,
2361                            handlers);
2362
2363           if (warning_as_error_callback)
2364             warning_as_error_callback (option_index);
2365         }
2366     }
2367   free (new_option);
2368 }
2369
2370 /* Return malloced memory for the name of the option OPTION_INDEX
2371    which enabled a diagnostic (context CONTEXT), originally of type
2372    ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2373    as -Werror.  */
2374
2375 char *
2376 option_name (diagnostic_context *context, int option_index,
2377              diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
2378 {
2379   if (option_index)
2380     {
2381       /* A warning classified as an error.  */
2382       if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
2383           && diag_kind == DK_ERROR)
2384         return concat (cl_options[OPT_Werror_].opt_text,
2385                        /* Skip over "-W".  */
2386                        cl_options[option_index].opt_text + 2,
2387                        NULL);
2388       /* A warning with option.  */
2389       else
2390         return xstrdup (cl_options[option_index].opt_text);
2391     }
2392   /* A warning without option classified as an error.  */
2393   else if (orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
2394            || diag_kind == DK_WARNING)
2395     {
2396       if (context->warning_as_error_requested)
2397         return xstrdup (cl_options[OPT_Werror].opt_text);
2398       else
2399         return xstrdup (_("enabled by default"));
2400     }
2401   else
2402     return NULL;
2403 }