gcc/opts.c

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