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