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