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_predictive_commoning = opt3;
 823   flag_inline_functions = opt3;
 824   flag_unswitch_loops = opt3;
 825   flag_gcse_after_reload = opt3;
 826   flag_tree_vectorize = opt3;
 827   flag_ipa_cp_clone = opt3;
 828   if (flag_ipa_cp_clone)
 829     flag_ipa_cp = 1;
 830
 831   /* Just -O1/-O0 optimizations.  */
 832   opt1_max = (optimize <= 1);
 833   align_loops = opt1_max;
 834   align_jumps = opt1_max;
 835   align_labels = opt1_max;
 836   align_functions = opt1_max;
 837
 838   if (optimize_size)
 839     {
 840       /* Inlining of functions reducing size is a good idea regardless of them
 841          being declared inline.  */
 842       flag_inline_functions = 1;
 843
 844       /* Basic optimization options.  */
 845       optimize_size = 1;
 846       if (optimize > 2)
 847         optimize = 2;
 848
 849       /* We want to crossjump as much as possible.  */
 850       set_param_value ("min-crossjump-insns", 1);
 851     }
 852   else
 853     set_param_value ("min-crossjump-insns", initial_min_crossjump_insns);
 854
 855   /* -Ofast adds optimizations to -O3.  */
 856   if (ofast)
 857     {
 858       /* Which is -ffast-math for now.  */
 859       set_fast_math_flags (1);
 860       /* Allow targets to enable extra options with -Ofast
 861          before general options processing so disabling them
 862          again afterwards works.  */
 863       targetm.handle_ofast ();
 864     }
 865
 866   /* Enable -Werror=coverage-mismatch by default */
 867   enable_warning_as_error ("coverage-mismatch", 1, lang_mask, &handlers);
 868
 869   if (first_time_p)
 870     {
 871       /* Initialize whether `char' is signed.  */
 872       flag_signed_char = DEFAULT_SIGNED_CHAR;
 873       /* Set this to a special "uninitialized" value.  The actual default is
 874          set after target options have been processed.  */
 875       flag_short_enums = 2;
 876
 877       /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
 878          modify it.  */
 879       target_flags = targetm.default_target_flags;
 880
 881       /* Some targets have ABI-specified unwind tables.  */
 882       flag_unwind_tables = targetm.unwind_tables_default;
 883     }
 884
 885 #ifdef ENABLE_LTO
 886   /* Clear any options currently held for LTO.  */
 887   lto_clear_user_options ();
 888 #endif
 889
 890 #ifdef OPTIMIZATION_OPTIONS
 891   /* Allow default optimizations to be specified on a per-machine basis.  */
 892   OPTIMIZATION_OPTIONS (optimize, optimize_size);
 893 #endif
 894
 895   read_cmdline_options (*decoded_options, *decoded_options_count, lang_mask,
 896                         &handlers);
 897
 898   if (dump_base_name && ! IS_ABSOLUTE_PATH (dump_base_name))
 899     {
 900       /* First try to make DUMP_BASE_NAME relative to the DUMP_DIR_NAME
 901          directory.  Then try to make DUMP_BASE_NAME relative to the
 902          AUX_BASE_NAME directory, typically the directory to contain
 903          the object file.  */
 904       if (dump_dir_name)
 905         dump_base_name = concat (dump_dir_name, dump_base_name, NULL);
 906       else if (aux_base_name)
 907         {
 908           const char *aux_base;
 909
 910           base_of_path (aux_base_name, &aux_base);
 911           if (aux_base_name != aux_base)
 912             {
 913               int dir_len = aux_base - aux_base_name;
 914               char *new_dump_base_name =
 915                 XNEWVEC (char, strlen(dump_base_name) + dir_len + 1);
 916
 917               /* Copy directory component from AUX_BASE_NAME.  */
 918               memcpy (new_dump_base_name, aux_base_name, dir_len);
 919               /* Append existing DUMP_BASE_NAME.  */
 920               strcpy (new_dump_base_name + dir_len, dump_base_name);
 921               dump_base_name = new_dump_base_name;
 922             }
 923         }
 924     }
 925
 926   /* Handle related options for unit-at-a-time, toplevel-reorder, and
 927      section-anchors.  */
 928   if (!flag_unit_at_a_time)
 929     {
 930       if (flag_section_anchors == 1)
 931         error ("Section anchors must be disabled when unit-at-a-time "
 932                "is disabled.");
 933       flag_section_anchors = 0;
 934       if (flag_toplevel_reorder == 1)
 935         error ("Toplevel reorder must be disabled when unit-at-a-time "
 936                "is disabled.");
 937       flag_toplevel_reorder = 0;
 938     }
 939
 940   /* -Wmissing-noreturn is alias for -Wsuggest-attribute=noreturn.  */
 941   if (warn_missing_noreturn)
 942     warn_suggest_attribute_noreturn = true;
 943
 944   /* Unless the user has asked for section anchors, we disable toplevel
 945      reordering at -O0 to disable transformations that might be surprising
 946      to end users and to get -fno-toplevel-reorder tested.  */
 947   if (!optimize && flag_toplevel_reorder == 2 && flag_section_anchors != 1)
 948     {
 949       flag_toplevel_reorder = 0;
 950       flag_section_anchors = 0;
 951     }
 952   if (!flag_toplevel_reorder)
 953     {
 954       if (flag_section_anchors == 1)
 955         error ("section anchors must be disabled when toplevel reorder"
 956                " is disabled");
 957       flag_section_anchors = 0;
 958     }
 959
 960   if (first_time_p)
 961     {
 962       if (flag_pie)
 963         flag_pic = flag_pie;
 964       if (flag_pic && !flag_pie)
 965         flag_shlib = 1;
 966       first_time_p = false;
 967     }
 968
 969   if (optimize == 0)
 970     {
 971       /* Inlining does not work if not optimizing,
 972          so force it not to be done.  */
 973       warn_inline = 0;
 974       flag_no_inline = 1;
 975     }
 976
 977   /* The optimization to partition hot and cold basic blocks into separate
 978      sections of the .o and executable files does not work (currently)
 979      with exception handling.  This is because there is no support for
 980      generating unwind info.  If flag_exceptions is turned on we need to
 981      turn off the partitioning optimization.  */
 982
 983   if (flag_exceptions && flag_reorder_blocks_and_partition
 984       && (USING_SJLJ_EXCEPTIONS
 985 #ifdef TARGET_UNWIND_INFO
 986           || 1
 987 #endif
 988          ))
 989     {
 990       inform (input_location,
 991               "-freorder-blocks-and-partition does not work with exceptions on this architecture");
 992       flag_reorder_blocks_and_partition = 0;
 993       flag_reorder_blocks = 1;
 994     }
 995
 996   /* If user requested unwind info, then turn off the partitioning
 997      optimization.  */
 998
 999   if (flag_unwind_tables && ! targetm.unwind_tables_default
1000       && flag_reorder_blocks_and_partition
1001       && (USING_SJLJ_EXCEPTIONS
1002 #ifdef TARGET_UNWIND_INFO
1003           || 1
1004 #endif
1005          ))
1006     {
1007       inform (input_location,
1008               "-freorder-blocks-and-partition does not support unwind info on this architecture");
1009       flag_reorder_blocks_and_partition = 0;
1010       flag_reorder_blocks = 1;
1011     }
1012
1013   /* If the target requested unwind info, then turn off the partitioning
1014      optimization with a different message.  Likewise, if the target does not
1015      support named sections.  */
1016
1017   if (flag_reorder_blocks_and_partition
1018       && (!targetm.have_named_sections
1019           || (flag_unwind_tables && targetm.unwind_tables_default
1020               && (USING_SJLJ_EXCEPTIONS
1021 #ifdef TARGET_UNWIND_INFO
1022                   || 1
1023 #endif
1024                  ))))
1025     {
1026       inform (input_location,
1027               "-freorder-blocks-and-partition does not work on this architecture");
1028       flag_reorder_blocks_and_partition = 0;
1029       flag_reorder_blocks = 1;
1030     }
1031
1032   /* Pipelining of outer loops is only possible when general pipelining
1033      capabilities are requested.  */
1034   if (!flag_sel_sched_pipelining)
1035     flag_sel_sched_pipelining_outer_loops = 0;
1036
1037   if (!targetm.ira_cover_classes
1038       && flag_ira_algorithm == IRA_ALGORITHM_CB)
1039     {
1040       inform (input_location,
1041               "-fira-algorithm=CB does not work on this architecture");
1042       flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1043     }
1044
1045   if (flag_conserve_stack)
1046     {
1047       if (!PARAM_SET_P (PARAM_LARGE_STACK_FRAME))
1048         PARAM_VALUE (PARAM_LARGE_STACK_FRAME) = 100;
1049       if (!PARAM_SET_P (PARAM_STACK_FRAME_GROWTH))
1050         PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) = 40;
1051     }
1052   if (flag_wpa || flag_ltrans)
1053     {
1054       /* These passes are not WHOPR compatible yet.  */
1055       flag_ipa_pta = 0;
1056       flag_ipa_struct_reorg = 0;
1057     }
1058
1059   if (flag_lto || flag_whopr)
1060     {
1061 #ifdef ENABLE_LTO
1062       flag_generate_lto = 1;
1063
1064       /* When generating IL, do not operate in whole-program mode.
1065          Otherwise, symbols will be privatized too early, causing link
1066          errors later.  */
1067       flag_whole_program = 0;
1068 #else
1069       error ("LTO support has not been enabled in this configuration");
1070 #endif
1071     }
1072
1073   /* Reconcile -flto and -fwhopr.  Set additional flags as appropriate and
1074      check option consistency.  */
1075   if (flag_lto && flag_whopr)
1076     error ("-flto and -fwhopr are mutually exclusive");
1077 }
1078
1079 #define LEFT_COLUMN     27
1080
1081 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1082    followed by word-wrapped HELP in a second column.  */
1083 static void
1084 wrap_help (const char *help,
1085            const char *item,
1086            unsigned int item_width,
1087            unsigned int columns)
1088 {
1089   unsigned int col_width = LEFT_COLUMN;
1090   unsigned int remaining, room, len;
1091
1092   remaining = strlen (help);
1093
1094   do
1095     {
1096       room = columns - 3 - MAX (col_width, item_width);
1097       if (room > columns)
1098         room = 0;
1099       len = remaining;
1100
1101       if (room < len)
1102         {
1103           unsigned int i;
1104
1105           for (i = 0; help[i]; i++)
1106             {
1107               if (i >= room && len != remaining)
1108                 break;
1109               if (help[i] == ' ')
1110                 len = i;
1111               else if ((help[i] == '-' || help[i] == '/')
1112                        && help[i + 1] != ' '
1113                        && i > 0 && ISALPHA (help[i - 1]))
1114                 len = i + 1;
1115             }
1116         }
1117
1118       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1119       item_width = 0;
1120       while (help[len] == ' ')
1121         len++;
1122       help += len;
1123       remaining -= len;
1124     }
1125   while (remaining);
1126 }
1127
1128 /* Print help for a specific front-end, etc.  */
1129 static void
1130 print_filtered_help (unsigned int include_flags,
1131                      unsigned int exclude_flags,
1132                      unsigned int any_flags,
1133                      unsigned int columns)
1134 {
1135   unsigned int i;
1136   const char *help;
1137   static char *printed = NULL;
1138   bool found = false;
1139   bool displayed = false;
1140
1141   if (include_flags == CL_PARAMS)
1142     {
1143       for (i = 0; i < LAST_PARAM; i++)
1144         {
1145           const char *param = compiler_params[i].option;
1146
1147           help = compiler_params[i].help;
1148           if (help == NULL || *help == '\0')
1149             {
1150               if (exclude_flags & CL_UNDOCUMENTED)
1151                 continue;
1152               help = undocumented_msg;
1153             }
1154
1155           /* Get the translation.  */
1156           help = _(help);
1157
1158           wrap_help (help, param, strlen (param), columns);
1159         }
1160       putchar ('\n');
1161       return;
1162     }
1163
1164   if (!printed)
1165     printed = XCNEWVAR (char, cl_options_count);
1166
1167   for (i = 0; i < cl_options_count; i++)
1168     {
1169       static char new_help[128];
1170       const struct cl_option *option = cl_options + i;
1171       unsigned int len;
1172       const char *opt;
1173       const char *tab;
1174
1175       if (include_flags == 0
1176           || ((option->flags & include_flags) != include_flags))
1177         {
1178           if ((option->flags & any_flags) == 0)
1179             continue;
1180         }
1181
1182       /* Skip unwanted switches.  */
1183       if ((option->flags & exclude_flags) != 0)
1184         continue;
1185
1186       found = true;
1187       /* Skip switches that have already been printed.  */
1188       if (printed[i])
1189         continue;
1190
1191       printed[i] = true;
1192
1193       help = option->help;
1194       if (help == NULL)
1195         {
1196           if (exclude_flags & CL_UNDOCUMENTED)
1197             continue;
1198           help = undocumented_msg;
1199         }
1200
1201       /* Get the translation.  */
1202       help = _(help);
1203
1204       /* Find the gap between the name of the
1205          option and its descriptive text.  */
1206       tab = strchr (help, '\t');
1207       if (tab)
1208         {
1209           len = tab - help;
1210           opt = help;
1211           help = tab + 1;
1212         }
1213       else
1214         {
1215           opt = option->opt_text;
1216           len = strlen (opt);
1217         }
1218
1219       /* With the -Q option enabled we change the descriptive text associated
1220          with an option to be an indication of its current setting.  */
1221       if (!quiet_flag)
1222         {
1223           if (len < (LEFT_COLUMN + 2))
1224             strcpy (new_help, "\t\t");
1225           else
1226             strcpy (new_help, "\t");
1227
1228           if (option->flag_var != NULL)
1229             {
1230               if (option->flags & CL_JOINED)
1231                 {
1232                   if (option->var_type == CLVC_STRING)
1233                     {
1234                       if (* (const char **) option->flag_var != NULL)
1235                         snprintf (new_help + strlen (new_help),
1236                                   sizeof (new_help) - strlen (new_help),
1237                                   * (const char **) option->flag_var);
1238                     }
1239                   else
1240                     sprintf (new_help + strlen (new_help),
1241                              "%#x", * (int *) option->flag_var);
1242                 }
1243               else
1244                 strcat (new_help, option_enabled (i)
1245                         ? _("[enabled]") : _("[disabled]"));
1246             }
1247
1248           help = new_help;
1249         }
1250
1251       wrap_help (help, opt, len, columns);
1252       displayed = true;
1253     }
1254
1255   if (! found)
1256     {
1257       unsigned int langs = include_flags & CL_LANG_ALL;
1258
1259       if (langs == 0)
1260         printf (_(" No options with the desired characteristics were found\n"));
1261       else
1262         {
1263           unsigned int i;
1264
1265           /* PR 31349: Tell the user how to see all of the
1266              options supported by a specific front end.  */
1267           for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1268             if ((1U << i) & langs)
1269               printf (_(" None found.  Use --help=%s to show *all* the options supported by the %s front-end\n"),
1270                       lang_names[i], lang_names[i]);
1271         }
1272
1273     }
1274   else if (! displayed)
1275     printf (_(" All options with the desired characteristics have already been displayed\n"));
1276
1277   putchar ('\n');
1278 }
1279
1280 /* Display help for a specified type of option.
1281    The options must have ALL of the INCLUDE_FLAGS set
1282    ANY of the flags in the ANY_FLAGS set
1283    and NONE of the EXCLUDE_FLAGS set.  */
1284 static void
1285 print_specific_help (unsigned int include_flags,
1286                      unsigned int exclude_flags,
1287                      unsigned int any_flags)
1288 {
1289   unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1290   const char * description = NULL;
1291   const char * descrip_extra = "";
1292   size_t i;
1293   unsigned int flag;
1294   static unsigned int columns = 0;
1295
1296   /* Sanity check: Make sure that we do not have more
1297      languages than we have bits available to enumerate them.  */
1298   gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
1299
1300   /* If we have not done so already, obtain
1301      the desired maximum width of the output.  */
1302   if (columns == 0)
1303     {
1304       const char *p;
1305
1306       GET_ENVIRONMENT (p, "COLUMNS");
1307       if (p != NULL)
1308         {
1309           int value = atoi (p);
1310
1311           if (value > 0)
1312             columns = value;
1313         }
1314
1315       if (columns == 0)
1316         /* Use a reasonable default.  */
1317         columns = 80;
1318     }
1319
1320   /* Decide upon the title for the options that we are going to display.  */
1321   for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1322     {
1323       switch (flag & include_flags)
1324         {
1325         case 0:
1326           break;
1327
1328         case CL_TARGET:
1329           description = _("The following options are target specific");
1330           break;
1331         case CL_WARNING:
1332           description = _("The following options control compiler warning messages");
1333           break;
1334         case CL_OPTIMIZATION:
1335           description = _("The following options control optimizations");
1336           break;
1337         case CL_COMMON:
1338           description = _("The following options are language-independent");
1339           break;
1340         case CL_PARAMS:
1341           description = _("The --param option recognizes the following as parameters");
1342           break;
1343         default:
1344           if (i >= cl_lang_count)
1345             break;
1346           if (exclude_flags & all_langs_mask)
1347             description = _("The following options are specific to just the language ");
1348           else
1349             description = _("The following options are supported by the language ");
1350           descrip_extra = lang_names [i];
1351           break;
1352         }
1353     }
1354
1355   if (description == NULL)
1356     {
1357       if (any_flags == 0)
1358         {
1359           if (include_flags & CL_UNDOCUMENTED)
1360             description = _("The following options are not documented");
1361           else if (include_flags & CL_SEPARATE)
1362             description = _("The following options take separate arguments");
1363           else if (include_flags & CL_JOINED)
1364             description = _("The following options take joined arguments");
1365           else
1366             {
1367               internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1368                               include_flags);
1369               return;
1370             }
1371         }
1372       else
1373         {
1374           if (any_flags & all_langs_mask)
1375             description = _("The following options are language-related");
1376           else
1377             description = _("The following options are language-independent");
1378         }
1379     }
1380
1381   printf ("%s%s:\n", description, descrip_extra);
1382   print_filtered_help (include_flags, exclude_flags, any_flags, columns);
1383 }
1384
1385 /* Handle target- and language-independent options.  Return zero to
1386    generate an "unknown option" message.  Only options that need
1387    extra handling need to be listed here; if you simply want
1388    VALUE assigned to a variable, it happens automatically.  */
1389
1390 static bool
1391 common_handle_option (size_t scode, const char *arg, int value,
1392                       unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
1393                       const struct cl_option_handlers *handlers)
1394 {
1395   static bool verbose = false;
1396   enum opt_code code = (enum opt_code) scode;
1397
1398   switch (code)
1399     {
1400     case OPT__param:
1401       handle_param (arg);
1402       break;
1403
1404     case OPT_v:
1405       verbose = true;
1406       break;
1407
1408     case OPT_fhelp:
1409     case OPT__help:
1410       {
1411         unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1412         unsigned int undoc_mask;
1413         unsigned int i;
1414
1415         undoc_mask = (verbose | extra_warnings) ? 0 : CL_UNDOCUMENTED;
1416         /* First display any single language specific options.  */
1417         for (i = 0; i < cl_lang_count; i++)
1418           print_specific_help
1419             (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0);
1420         /* Next display any multi language specific options.  */
1421         print_specific_help (0, undoc_mask, all_langs_mask);
1422         /* Then display any remaining, non-language options.  */
1423         for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1424           print_specific_help (i, undoc_mask, 0);
1425         exit_after_options = true;
1426         break;
1427       }
1428
1429     case OPT_ftarget_help:
1430     case OPT__target_help:
1431       print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0);
1432       exit_after_options = true;
1433
1434       /* Allow the target a chance to give the user some additional information.  */
1435       if (targetm.help)
1436         targetm.help ();
1437       break;
1438
1439     case OPT_fhelp_:
1440     case OPT__help_:
1441       {
1442         const char * a = arg;
1443         unsigned int include_flags = 0;
1444         /* Note - by default we include undocumented options when listing
1445            specific classes.  If you only want to see documented options
1446            then add ",^undocumented" to the --help= option.  E.g.:
1447
1448            --help=target,^undocumented  */
1449         unsigned int exclude_flags = 0;
1450
1451         /* Walk along the argument string, parsing each word in turn.
1452            The format is:
1453            arg = [^]{word}[,{arg}]
1454            word = {optimizers|target|warnings|undocumented|
1455                    params|common|<language>}  */
1456         while (* a != 0)
1457           {
1458             static struct
1459             {
1460               const char * string;
1461               unsigned int flag;
1462             }
1463             specifics[] =
1464             {
1465               { "optimizers", CL_OPTIMIZATION },
1466               { "target", CL_TARGET },
1467               { "warnings", CL_WARNING },
1468               { "undocumented", CL_UNDOCUMENTED },
1469               { "params", CL_PARAMS },
1470               { "joined", CL_JOINED },
1471               { "separate", CL_SEPARATE },
1472               { "common", CL_COMMON },
1473               { NULL, 0 }
1474             };
1475             unsigned int * pflags;
1476             const char * comma;
1477             unsigned int lang_flag, specific_flag;
1478             unsigned int len;
1479             unsigned int i;
1480
1481             if (* a == '^')
1482               {
1483                 ++ a;
1484                 pflags = & exclude_flags;
1485               }
1486             else
1487               pflags = & include_flags;
1488
1489             comma = strchr (a, ',');
1490             if (comma == NULL)
1491               len = strlen (a);
1492             else
1493               len = comma - a;
1494             if (len == 0)
1495               {
1496                 a = comma + 1;
1497                 continue;
1498               }
1499
1500             /* Check to see if the string matches an option class name.  */
1501             for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1502               if (strncasecmp (a, specifics[i].string, len) == 0)
1503                 {
1504                   specific_flag = specifics[i].flag;
1505                   break;
1506                 }
1507
1508             /* Check to see if the string matches a language name.
1509                Note - we rely upon the alpha-sorted nature of the entries in
1510                the lang_names array, specifically that shorter names appear
1511                before their longer variants.  (i.e. C before C++).  That way
1512                when we are attempting to match --help=c for example we will
1513                match with C first and not C++.  */
1514             for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1515               if (strncasecmp (a, lang_names[i], len) == 0)
1516                 {
1517                   lang_flag = 1U << i;
1518                   break;
1519                 }
1520
1521             if (specific_flag != 0)
1522               {
1523                 if (lang_flag == 0)
1524                   * pflags |= specific_flag;
1525                 else
1526                   {
1527                     /* The option's argument matches both the start of a
1528                        language name and the start of an option class name.
1529                        We have a special case for when the user has
1530                        specified "--help=c", but otherwise we have to issue
1531                        a warning.  */
1532                     if (strncasecmp (a, "c", len) == 0)
1533                       * pflags |= lang_flag;
1534                     else
1535                       fnotice (stderr,
1536                                "warning: --help argument %.*s is ambiguous, please be more specific\n",
1537                                len, a);
1538                   }
1539               }
1540             else if (lang_flag != 0)
1541               * pflags |= lang_flag;
1542             else
1543               fnotice (stderr,
1544                        "warning: unrecognized argument to --help= option: %.*s\n",
1545                        len, a);
1546
1547             if (comma == NULL)
1548               break;
1549             a = comma + 1;
1550           }
1551
1552         if (include_flags)
1553           print_specific_help (include_flags, exclude_flags, 0);
1554         exit_after_options = true;
1555         break;
1556       }
1557
1558     case OPT_fversion:
1559     case OPT__version:
1560       exit_after_options = true;
1561       break;
1562
1563     case OPT_O:
1564     case OPT_Os:
1565     case OPT_Ofast:
1566       /* Currently handled in a prescan.  */
1567       break;
1568
1569     case OPT_Werror_:
1570       enable_warning_as_error (arg, value, lang_mask, handlers);
1571       break;
1572
1573     case OPT_Wlarger_than_:
1574       /* This form corresponds to -Wlarger-than-.
1575          Kept for backward compatibility.
1576          Don't use it as the first argument of warning().  */
1577
1578     case OPT_Wlarger_than_eq:
1579       larger_than_size = value;
1580       warn_larger_than = value != -1;
1581       break;
1582
1583     case OPT_Wfatal_errors:
1584       global_dc->fatal_errors = value;
1585       break;
1586
1587     case OPT_Wframe_larger_than_:
1588       frame_larger_than_size = value;
1589       warn_frame_larger_than = value != -1;
1590       break;
1591
1592     case OPT_Wstrict_aliasing:
1593       set_Wstrict_aliasing (value);
1594       break;
1595
1596     case OPT_Wstrict_aliasing_:
1597       warn_strict_aliasing = value;
1598       break;
1599
1600     case OPT_Wstrict_overflow:
1601       warn_strict_overflow = (value
1602                               ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1603                               : 0);
1604       break;
1605
1606     case OPT_Wstrict_overflow_:
1607       warn_strict_overflow = value;
1608       break;
1609
1610     case OPT_Wsystem_headers:
1611       global_dc->warn_system_headers = value;
1612       break;
1613
1614     case OPT_Wunused:
1615       warn_unused = value;
1616       break;
1617
1618     case OPT_aux_info:
1619     case OPT_aux_info_:
1620       aux_info_file_name = arg;
1621       flag_gen_aux_info = 1;
1622       break;
1623
1624     case OPT_auxbase:
1625       aux_base_name = arg;
1626       break;
1627
1628     case OPT_auxbase_strip:
1629       {
1630         char *tmp = xstrdup (arg);
1631         strip_off_ending (tmp, strlen (tmp));
1632         if (tmp[0])
1633           aux_base_name = tmp;
1634       }
1635       break;
1636
1637     case OPT_d:
1638       decode_d_option (arg);
1639       break;
1640
1641     case OPT_dumpbase:
1642       dump_base_name = arg;
1643       break;
1644
1645     case OPT_dumpdir:
1646       dump_dir_name = arg;
1647       break;
1648
1649     case OPT_falign_functions_:
1650       align_functions = value;
1651       break;
1652
1653     case OPT_falign_jumps_:
1654       align_jumps = value;
1655       break;
1656
1657     case OPT_falign_labels_:
1658       align_labels = value;
1659       break;
1660
1661     case OPT_falign_loops_:
1662       align_loops = value;
1663       break;
1664
1665     case OPT_fbranch_probabilities:
1666       flag_branch_probabilities_set = true;
1667       break;
1668
1669     case OPT_fcall_used_:
1670       fix_register (arg, 0, 1);
1671       break;
1672
1673     case OPT_fcall_saved_:
1674       fix_register (arg, 0, 0);
1675       break;
1676
1677     case OPT_fdbg_cnt_:
1678       dbg_cnt_process_opt (arg);
1679       break;
1680
1681     case OPT_fdbg_cnt_list:
1682       dbg_cnt_list_all_counters ();
1683       break;
1684
1685     case OPT_fdebug_prefix_map_:
1686       add_debug_prefix_map (arg);
1687       break;
1688
1689     case OPT_fdiagnostics_show_location_:
1690       if (!strcmp (arg, "once"))
1691         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
1692       else if (!strcmp (arg, "every-line"))
1693         diagnostic_prefixing_rule (global_dc)
1694           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
1695       else
1696         return false;
1697       break;
1698
1699     case OPT_fdiagnostics_show_option:
1700       global_dc->show_option_requested = value;
1701       break;
1702
1703     case OPT_fdump_:
1704       if (!dump_switch_p (arg))
1705         return false;
1706       break;
1707
1708     case OPT_fexcess_precision_:
1709       if (!strcmp (arg, "fast"))
1710         flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
1711       else if (!strcmp (arg, "standard"))
1712         flag_excess_precision_cmdline = EXCESS_PRECISION_STANDARD;
1713       else
1714         error ("unknown excess precision style \"%s\"", arg);
1715       break;
1716
1717     case OPT_ffast_math:
1718       set_fast_math_flags (value);
1719       break;
1720
1721     case OPT_funsafe_math_optimizations:
1722       set_unsafe_math_optimizations_flags (value);
1723       break;
1724
1725     case OPT_ffixed_:
1726       fix_register (arg, 1, 1);
1727       break;
1728
1729     case OPT_finline_limit_:
1730     case OPT_finline_limit_eq:
1731       set_param_value ("max-inline-insns-single", value / 2);
1732       set_param_value ("max-inline-insns-auto", value / 2);
1733       break;
1734
1735     case OPT_finstrument_functions_exclude_function_list_:
1736       add_comma_separated_to_vector
1737         (&flag_instrument_functions_exclude_functions, arg);
1738       break;
1739
1740     case OPT_finstrument_functions_exclude_file_list_:
1741       add_comma_separated_to_vector
1742         (&flag_instrument_functions_exclude_files, arg);
1743       break;
1744
1745     case OPT_fmessage_length_:
1746       pp_set_line_maximum_length (global_dc->printer, value);
1747       break;
1748
1749     case OPT_fpack_struct_:
1750       if (value <= 0 || (value & (value - 1)) || value > 16)
1751         error ("structure alignment must be a small power of two, not %d", value);
1752       else
1753         {
1754           initial_max_fld_align = value;
1755           maximum_field_alignment = value * BITS_PER_UNIT;
1756         }
1757       break;
1758
1759     case OPT_fpeel_loops:
1760       flag_peel_loops_set = true;
1761       break;
1762
1763     case OPT_fplugin_:
1764 #ifdef ENABLE_PLUGIN
1765       add_new_plugin (arg);
1766 #else
1767       error ("Plugin support is disabled.  Configure with --enable-plugin.");
1768 #endif
1769       break;
1770
1771     case OPT_fplugin_arg_:
1772 #ifdef ENABLE_PLUGIN
1773       parse_plugin_arg_opt (arg);
1774 #else
1775       error ("Plugin support is disabled.  Configure with --enable-plugin.");
1776 #endif
1777       break;
1778
1779     case OPT_fprofile_arcs:
1780       profile_arc_flag_set = true;
1781       break;
1782
1783     case OPT_finline_functions:
1784       flag_inline_functions_set = true;
1785       break;
1786
1787     case OPT_fprofile_dir_:
1788       profile_data_prefix = xstrdup (arg);
1789       break;
1790
1791     case OPT_fprofile_use_:
1792       profile_data_prefix = xstrdup (arg);
1793       flag_profile_use = true;
1794       value = true;
1795       /* No break here - do -fprofile-use processing. */
1796     case OPT_fprofile_use:
1797       if (!flag_branch_probabilities_set)
1798         flag_branch_probabilities = value;
1799       if (!flag_profile_values_set)
1800         flag_profile_values = value;
1801       if (!flag_unroll_loops_set)
1802         flag_unroll_loops = value;
1803       if (!flag_peel_loops_set)
1804         flag_peel_loops = value;
1805       if (!flag_tracer_set)
1806         flag_tracer = value;
1807       if (!flag_value_profile_transformations_set)
1808         flag_value_profile_transformations = value;
1809       if (!flag_inline_functions_set)
1810         flag_inline_functions = value;
1811       if (!flag_ipa_cp_set)
1812         flag_ipa_cp = value;
1813       if (!flag_ipa_cp_clone_set
1814           && value && flag_ipa_cp)
1815         flag_ipa_cp_clone = value;
1816       if (!flag_predictive_commoning_set)
1817         flag_predictive_commoning = value;
1818       if (!flag_unswitch_loops_set)
1819         flag_unswitch_loops = value;
1820       if (!flag_gcse_after_reload_set)
1821         flag_gcse_after_reload = value;
1822       break;
1823
1824     case OPT_fprofile_generate_:
1825       profile_data_prefix = xstrdup (arg);
1826       value = true;
1827       /* No break here - do -fprofile-generate processing. */
1828     case OPT_fprofile_generate:
1829       if (!profile_arc_flag_set)
1830         profile_arc_flag = value;
1831       if (!flag_profile_values_set)
1832         flag_profile_values = value;
1833       if (!flag_value_profile_transformations_set)
1834         flag_value_profile_transformations = value;
1835       if (!flag_inline_functions_set)
1836         flag_inline_functions = value;
1837       break;
1838
1839     case OPT_fprofile_values:
1840       flag_profile_values_set = true;
1841       break;
1842
1843     case OPT_fshow_column:
1844       global_dc->show_column = value;
1845       break;
1846
1847     case OPT_fvisibility_:
1848       {
1849         if (!strcmp(arg, "default"))
1850           default_visibility = VISIBILITY_DEFAULT;
1851         else if (!strcmp(arg, "internal"))
1852           default_visibility = VISIBILITY_INTERNAL;
1853         else if (!strcmp(arg, "hidden"))
1854           default_visibility = VISIBILITY_HIDDEN;
1855         else if (!strcmp(arg, "protected"))
1856           default_visibility = VISIBILITY_PROTECTED;
1857         else
1858           error ("unrecognized visibility value \"%s\"", arg);
1859       }
1860       break;
1861
1862     case OPT_fvpt:
1863       flag_value_profile_transformations_set = true;
1864       break;
1865
1866     case OPT_frandom_seed:
1867       /* The real switch is -fno-random-seed.  */
1868       if (value)
1869         return false;
1870       set_random_seed (NULL);
1871       break;
1872
1873     case OPT_frandom_seed_:
1874       set_random_seed (arg);
1875       break;
1876
1877     case OPT_fselective_scheduling:
1878     case OPT_fselective_scheduling2:
1879       sel_sched_switch_set = true;
1880       break;
1881
1882     case OPT_fsched_verbose_:
1883 #ifdef INSN_SCHEDULING
1884       fix_sched_param ("verbose", arg);
1885       break;
1886 #else
1887       return false;
1888 #endif
1889
1890     case OPT_fsched_stalled_insns_:
1891       flag_sched_stalled_insns = value;
1892       if (flag_sched_stalled_insns == 0)
1893         flag_sched_stalled_insns = -1;
1894       break;
1895
1896     case OPT_fsched_stalled_insns_dep_:
1897       flag_sched_stalled_insns_dep = value;
1898       break;
1899
1900     case OPT_fstack_check_:
1901       if (!strcmp (arg, "no"))
1902         flag_stack_check = NO_STACK_CHECK;
1903       else if (!strcmp (arg, "generic"))
1904         /* This is the old stack checking method.  */
1905         flag_stack_check = STACK_CHECK_BUILTIN
1906                            ? FULL_BUILTIN_STACK_CHECK
1907                            : GENERIC_STACK_CHECK;
1908       else if (!strcmp (arg, "specific"))
1909         /* This is the new stack checking method.  */
1910         flag_stack_check = STACK_CHECK_BUILTIN
1911                            ? FULL_BUILTIN_STACK_CHECK
1912                            : STACK_CHECK_STATIC_BUILTIN
1913                              ? STATIC_BUILTIN_STACK_CHECK
1914                              : GENERIC_STACK_CHECK;
1915       else
1916         warning (0, "unknown stack check parameter \"%s\"", arg);
1917       break;
1918
1919     case OPT_fstack_check:
1920       /* This is the same as the "specific" mode above.  */
1921       if (value)
1922         flag_stack_check = STACK_CHECK_BUILTIN
1923                            ? FULL_BUILTIN_STACK_CHECK
1924                            : STACK_CHECK_STATIC_BUILTIN
1925                              ? STATIC_BUILTIN_STACK_CHECK
1926                              : GENERIC_STACK_CHECK;
1927       else
1928         flag_stack_check = NO_STACK_CHECK;
1929       break;
1930
1931     case OPT_fstack_limit:
1932       /* The real switch is -fno-stack-limit.  */
1933       if (value)
1934         return false;
1935       stack_limit_rtx = NULL_RTX;
1936       break;
1937
1938     case OPT_fstack_limit_register_:
1939       {
1940         int reg = decode_reg_name (arg);
1941         if (reg < 0)
1942           error ("unrecognized register name \"%s\"", arg);
1943         else
1944           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1945       }
1946       break;
1947
1948     case OPT_fstack_limit_symbol_:
1949       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1950       break;
1951
1952     case OPT_ftree_vectorizer_verbose_:
1953       vect_set_verbosity_level (arg);
1954       break;
1955
1956     case OPT_ftls_model_:
1957       if (!strcmp (arg, "global-dynamic"))
1958         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1959       else if (!strcmp (arg, "local-dynamic"))
1960         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1961       else if (!strcmp (arg, "initial-exec"))
1962         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1963       else if (!strcmp (arg, "local-exec"))
1964         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1965       else
1966         warning (0, "unknown tls-model \"%s\"", arg);
1967       break;
1968
1969     case OPT_fira_algorithm_:
1970       if (!strcmp (arg, "CB"))
1971         flag_ira_algorithm = IRA_ALGORITHM_CB;
1972       else if (!strcmp (arg, "priority"))
1973         flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1974       else
1975         warning (0, "unknown ira algorithm \"%s\"", arg);
1976       break;
1977
1978     case OPT_fira_region_:
1979       if (!strcmp (arg, "one"))
1980         flag_ira_region = IRA_REGION_ONE;
1981       else if (!strcmp (arg, "all"))
1982         flag_ira_region = IRA_REGION_ALL;
1983       else if (!strcmp (arg, "mixed"))
1984         flag_ira_region = IRA_REGION_MIXED;
1985       else
1986         warning (0, "unknown ira region \"%s\"", arg);
1987       break;
1988
1989     case OPT_fira_verbose_:
1990       flag_ira_verbose = value;
1991       break;
1992
1993     case OPT_ftracer:
1994       flag_tracer_set = true;
1995       break;
1996
1997     case OPT_fipa_cp:
1998       flag_ipa_cp_set = true;
1999       break;
2000
2001     case OPT_fipa_cp_clone:
2002       flag_ipa_cp_clone_set = true;
2003       break;
2004
2005     case OPT_fpredictive_commoning:
2006       flag_predictive_commoning_set = true;
2007       break;
2008
2009     case OPT_funswitch_loops:
2010       flag_unswitch_loops_set = true;
2011       break;
2012
2013     case OPT_fgcse_after_reload:
2014       flag_gcse_after_reload_set = true;
2015       break;
2016
2017     case OPT_funroll_loops:
2018       flag_unroll_loops_set = true;
2019       break;
2020
2021     case OPT_g:
2022       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
2023       break;
2024
2025     case OPT_gcoff:
2026       set_debug_level (SDB_DEBUG, false, arg);
2027       break;
2028
2029     case OPT_gdwarf_:
2030       if (value < 2 || value > 4)
2031         error ("dwarf version %d is not supported", value);
2032       else
2033         dwarf_version = value;
2034       set_debug_level (DWARF2_DEBUG, false, "");
2035       break;
2036
2037     case OPT_ggdb:
2038       set_debug_level (NO_DEBUG, 2, arg);
2039       break;
2040
2041     case OPT_gstabs:
2042     case OPT_gstabs_:
2043       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
2044       break;
2045
2046     case OPT_gvms:
2047       set_debug_level (VMS_DEBUG, false, arg);
2048       break;
2049
2050     case OPT_gxcoff:
2051     case OPT_gxcoff_:
2052       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
2053       break;
2054
2055     case OPT_o:
2056       asm_file_name = arg;
2057       break;
2058
2059     case OPT_pedantic_errors:
2060       flag_pedantic_errors = pedantic = 1;
2061       global_dc->pedantic_errors = 1;
2062       break;
2063
2064     case OPT_fwhopr:
2065       flag_whopr = value;
2066       break;
2067
2068     case OPT_w:
2069       global_dc->inhibit_warnings = true;
2070       break;
2071
2072     case OPT_fsee:
2073     case OPT_fcse_skip_blocks:
2074     case OPT_floop_optimize:
2075     case OPT_frerun_loop_opt:
2076     case OPT_fsched2_use_traces:
2077     case OPT_fstrength_reduce:
2078     case OPT_ftree_store_copy_prop:
2079     case OPT_fforce_addr:
2080     case OPT_ftree_salias:
2081     case OPT_ftree_store_ccp:
2082     case OPT_Wunreachable_code:
2083     case OPT_fargument_alias:
2084     case OPT_fargument_noalias:
2085     case OPT_fargument_noalias_anything:
2086     case OPT_fargument_noalias_global:
2087       /* These are no-ops, preserved for backward compatibility.  */
2088       break;
2089
2090     case OPT_fuse_linker_plugin:
2091       /* No-op. Used by the driver and passed to us because it starts with f.*/
2092       break;
2093
2094     default:
2095       /* If the flag was handled in a standard way, assume the lack of
2096          processing here is intentional.  */
2097       gcc_assert (cl_options[scode].flag_var);
2098       break;
2099     }
2100
2101   return true;
2102 }
2103
2104 /* Handle --param NAME=VALUE.  */
2105 static void
2106 handle_param (const char *carg)
2107 {
2108   char *equal, *arg;
2109   int value;
2110
2111   arg = xstrdup (carg);
2112   equal = strchr (arg, '=');
2113   if (!equal)
2114     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
2115   else
2116     {
2117       value = integral_argument (equal + 1);
2118       if (value == -1)
2119         error ("invalid --param value %qs", equal + 1);
2120       else
2121         {
2122           *equal = '\0';
2123           set_param_value (arg, value);
2124         }
2125     }
2126
2127   free (arg);
2128 }
2129
2130 /* Used to set the level of strict aliasing warnings,
2131    when no level is specified (i.e., when -Wstrict-aliasing, and not
2132    -Wstrict-aliasing=level was given).
2133    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2134    and 0 otherwise.  After calling this function, wstrict_aliasing will be
2135    set to the default value of -Wstrict_aliasing=level, currently 3.  */
2136 void
2137 set_Wstrict_aliasing (int onoff)
2138 {
2139   gcc_assert (onoff == 0 || onoff == 1);
2140   if (onoff != 0)
2141     warn_strict_aliasing = 3;
2142   else
2143     warn_strict_aliasing = 0;
2144 }
2145
2146 /* The following routines are useful in setting all the flags that
2147    -ffast-math and -fno-fast-math imply.  */
2148 void
2149 set_fast_math_flags (int set)
2150 {
2151   flag_unsafe_math_optimizations = set;
2152   set_unsafe_math_optimizations_flags (set);
2153   flag_finite_math_only = set;
2154   flag_errno_math = !set;
2155   if (set)
2156     {
2157       flag_signaling_nans = 0;
2158       flag_rounding_math = 0;
2159       flag_cx_limited_range = 1;
2160     }
2161 }
2162
2163 /* When -funsafe-math-optimizations is set the following
2164    flags are set as well.  */
2165 void
2166 set_unsafe_math_optimizations_flags (int set)
2167 {
2168   flag_trapping_math = !set;
2169   flag_signed_zeros = !set;
2170   flag_associative_math = set;
2171   flag_reciprocal_math = set;
2172 }
2173
2174 /* Return true iff flags are set as if -ffast-math.  */
2175 bool
2176 fast_math_flags_set_p (void)
2177 {
2178   return (!flag_trapping_math
2179           && flag_unsafe_math_optimizations
2180           && flag_finite_math_only
2181           && !flag_signed_zeros
2182           && !flag_errno_math);
2183 }
2184
2185 /* Return true iff flags are set as if -ffast-math but using the flags stored
2186    in the struct cl_optimization structure.  */
2187 bool
2188 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2189 {
2190   return (!opt->flag_trapping_math
2191           && opt->flag_unsafe_math_optimizations
2192           && opt->flag_finite_math_only
2193           && !opt->flag_signed_zeros
2194           && !opt->flag_errno_math);
2195 }
2196
2197 /* Handle a debug output -g switch.  EXTENDED is true or false to support
2198    extended output (2 is special and means "-ggdb" was given).  */
2199 static void
2200 set_debug_level (enum debug_info_type type, int extended, const char *arg)
2201 {
2202   static bool type_explicit;
2203
2204   use_gnu_debug_info_extensions = extended;
2205
2206   if (type == NO_DEBUG)
2207     {
2208       if (write_symbols == NO_DEBUG)
2209         {
2210           write_symbols = PREFERRED_DEBUGGING_TYPE;
2211
2212           if (extended == 2)
2213             {
2214 #ifdef DWARF2_DEBUGGING_INFO
2215               write_symbols = DWARF2_DEBUG;
2216 #elif defined DBX_DEBUGGING_INFO
2217               write_symbols = DBX_DEBUG;
2218 #endif
2219             }
2220
2221           if (write_symbols == NO_DEBUG)
2222             warning (0, "target system does not support debug output");
2223         }
2224     }
2225   else
2226     {
2227       /* Does it conflict with an already selected type?  */
2228       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
2229         error ("debug format \"%s\" conflicts with prior selection",
2230                debug_type_names[type]);
2231       write_symbols = type;
2232       type_explicit = true;
2233     }
2234
2235   /* A debug flag without a level defaults to level 2.  */
2236   if (*arg == '\0')
2237     {
2238       if (!debug_info_level)
2239         debug_info_level = DINFO_LEVEL_NORMAL;
2240     }
2241   else
2242     {
2243       int argval = integral_argument (arg);
2244       if (argval == -1)
2245         error ("unrecognised debug output level \"%s\"", arg);
2246       else if (argval > 3)
2247         error ("debug output level %s is too high", arg);
2248       else
2249         debug_info_level = (enum debug_info_level) argval;
2250     }
2251 }
2252
2253 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
2254    a simple on-off switch.  */
2255
2256 int
2257 option_enabled (int opt_idx)
2258 {
2259   const struct cl_option *option = &(cl_options[opt_idx]);
2260
2261   if (option->flag_var)
2262     switch (option->var_type)
2263       {
2264       case CLVC_BOOLEAN:
2265         return *(int *) option->flag_var != 0;
2266
2267       case CLVC_EQUAL:
2268         return *(int *) option->flag_var == option->var_value;
2269
2270       case CLVC_BIT_CLEAR:
2271         return (*(int *) option->flag_var & option->var_value) == 0;
2272
2273       case CLVC_BIT_SET:
2274         return (*(int *) option->flag_var & option->var_value) != 0;
2275
2276       case CLVC_STRING:
2277         break;
2278       }
2279   return -1;
2280 }
2281
2282 /* Fill STATE with the current state of option OPTION.  Return true if
2283    there is some state to store.  */
2284
2285 bool
2286 get_option_state (int option, struct cl_option_state *state)
2287 {
2288   if (cl_options[option].flag_var == 0)
2289     return false;
2290
2291   switch (cl_options[option].var_type)
2292     {
2293     case CLVC_BOOLEAN:
2294     case CLVC_EQUAL:
2295       state->data = cl_options[option].flag_var;
2296       state->size = sizeof (int);
2297       break;
2298
2299     case CLVC_BIT_CLEAR:
2300     case CLVC_BIT_SET:
2301       state->ch = option_enabled (option);
2302       state->data = &state->ch;
2303       state->size = 1;
2304       break;
2305
2306     case CLVC_STRING:
2307       state->data = *(const char **) cl_options[option].flag_var;
2308       if (state->data == 0)
2309         state->data = "";
2310       state->size = strlen ((const char *) state->data) + 1;
2311       break;
2312     }
2313   return true;
2314 }
2315
2316 /* Callback function, called when -Werror= enables a warning.  */
2317
2318 static void (*warning_as_error_callback) (int) = NULL;
2319
2320 /* Register a callback for enable_warning_as_error calls.  */
2321
2322 void
2323 register_warning_as_error_callback (void (*callback) (int))
2324 {
2325   gcc_assert (warning_as_error_callback == NULL || callback == NULL);
2326   warning_as_error_callback = callback;
2327 }
2328
2329 /* Enable a warning option as an error.  This is used by -Werror= and
2330    also by legacy Werror-implicit-function-declaration.  */
2331
2332 void
2333 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
2334                          const struct cl_option_handlers *handlers)
2335 {
2336   char *new_option;
2337   int option_index;
2338
2339   new_option = XNEWVEC (char, strlen (arg) + 2);
2340   new_option[0] = 'W';
2341   strcpy (new_option + 1, arg);
2342   option_index = find_opt (new_option, lang_mask);
2343   if (option_index == OPT_SPECIAL_unknown)
2344     {
2345       error ("-Werror=%s: No option -%s", arg, new_option);
2346     }
2347   else
2348     {
2349       const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
2350
2351       diagnostic_classify_diagnostic (global_dc, option_index, kind,
2352                                       UNKNOWN_LOCATION);
2353       if (kind == DK_ERROR)
2354         {
2355           const struct cl_option * const option = cl_options + option_index;
2356
2357           /* -Werror=foo implies -Wfoo.  */
2358           if (option->var_type == CLVC_BOOLEAN)
2359             handle_option (option_index, arg, value, lang_mask, (int)kind,
2360                            handlers);
2361
2362           if (warning_as_error_callback)
2363             warning_as_error_callback (option_index);
2364         }
2365     }
2366   free (new_option);
2367 }
2368
2369 /* Return malloced memory for the name of the option OPTION_INDEX
2370    which enabled a diagnostic (context CONTEXT), originally of type
2371    ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2372    as -Werror.  */
2373
2374 char *
2375 option_name (diagnostic_context *context, int option_index,
2376              diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
2377 {
2378   if (option_index)
2379     {
2380       /* A warning classified as an error.  */
2381       if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
2382           && diag_kind == DK_ERROR)
2383         return concat (cl_options[OPT_Werror_].opt_text,
2384                        /* Skip over "-W".  */
2385                        cl_options[option_index].opt_text + 2,
2386                        NULL);
2387       /* A warning with option.  */
2388       else
2389         return xstrdup (cl_options[option_index].opt_text);
2390     }
2391   /* A warning without option classified as an error.  */
2392   else if (orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
2393            || diag_kind == DK_WARNING)
2394     {
2395       if (context->warning_as_error_requested)
2396         return xstrdup (cl_options[OPT_Werror].opt_text);
2397       else
2398         return xstrdup (_("enabled by default"));
2399     }
2400   else
2401     return NULL;
2402 }