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