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