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