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