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