gcc/opts.c

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