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