gcc/opts.c

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