gcc/opts.c

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