gcc/opts.c

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