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   /* Enable -Werror=coverage-mismatch by default */
 950   enable_warning_as_error("coverage-mismatch", 1, lang_mask);
 951
 952   if (first_time_p)
 953     {
 954       /* Initialize whether `char' is signed.  */
 955       flag_signed_char = DEFAULT_SIGNED_CHAR;
 956       /* Set this to a special "uninitialized" value.  The actual default is
 957          set after target options have been processed.  */
 958       flag_short_enums = 2;
 959
 960       /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
 961          modify it.  */
 962       target_flags = targetm.default_target_flags;
 963
 964       /* Some targets have ABI-specified unwind tables.  */
 965       flag_unwind_tables = targetm.unwind_tables_default;
 966     }
 967
 968   /* Clear any options currently held for LTO.  */
 969   lto_clear_user_options ();
 970
 971 #ifdef OPTIMIZATION_OPTIONS
 972   /* Allow default optimizations to be specified on a per-machine basis.  */
 973   OPTIMIZATION_OPTIONS (optimize, optimize_size);
 974 #endif
 975
 976   handle_options (argc, argv, lang_mask);
 977
 978   if (dump_base_name && ! IS_ABSOLUTE_PATH (dump_base_name))
 979     {
 980       /* First try to make DUMP_BASE_NAME relative to the DUMP_DIR_NAME
 981          directory.  Then try to make DUMP_BASE_NAME relative to the
 982          AUX_BASE_NAME directory, typically the directory to contain
 983          the object file.  */
 984       if (dump_dir_name)
 985         dump_base_name = concat (dump_dir_name, dump_base_name, NULL);
 986       else if (aux_base_name)
 987         {
 988           const char *aux_base;
 989
 990           base_of_path (aux_base_name, &aux_base);
 991           if (aux_base_name != aux_base)
 992             {
 993               int dir_len = aux_base - aux_base_name;
 994               char *new_dump_base_name =
 995                 XNEWVEC (char, strlen(dump_base_name) + dir_len + 1);
 996
 997               /* Copy directory component from AUX_BASE_NAME.  */
 998               memcpy (new_dump_base_name, aux_base_name, dir_len);
 999               /* Append existing DUMP_BASE_NAME.  */
1000               strcpy (new_dump_base_name + dir_len, dump_base_name);
1001               dump_base_name = new_dump_base_name;
1002             }
1003         }
1004     }
1005
1006   /* Handle related options for unit-at-a-time, toplevel-reorder, and
1007      section-anchors.  */
1008   if (!flag_unit_at_a_time)
1009     {
1010       if (flag_section_anchors == 1)
1011         error ("Section anchors must be disabled when unit-at-a-time "
1012                "is disabled.");
1013       flag_section_anchors = 0;
1014       if (flag_toplevel_reorder == 1)
1015         error ("Toplevel reorder must be disabled when unit-at-a-time "
1016                "is disabled.");
1017       flag_toplevel_reorder = 0;
1018     }
1019   /* Unless the user has asked for section anchors, we disable toplevel
1020      reordering at -O0 to disable transformations that might be surprising
1021      to end users and to get -fno-toplevel-reorder tested.  */
1022   if (!optimize && flag_toplevel_reorder == 2 && flag_section_anchors != 1)
1023     {
1024       flag_toplevel_reorder = 0;
1025       flag_section_anchors = 0;
1026     }
1027   if (!flag_toplevel_reorder)
1028     {
1029       if (flag_section_anchors == 1)
1030         error ("section anchors must be disabled when toplevel reorder"
1031                " is disabled");
1032       flag_section_anchors = 0;
1033     }
1034
1035   if (first_time_p)
1036     {
1037       if (flag_pie)
1038         flag_pic = flag_pie;
1039       if (flag_pic && !flag_pie)
1040         flag_shlib = 1;
1041       first_time_p = false;
1042     }
1043
1044   if (optimize == 0)
1045     {
1046       /* Inlining does not work if not optimizing,
1047          so force it not to be done.  */
1048       warn_inline = 0;
1049       flag_no_inline = 1;
1050     }
1051
1052   /* The optimization to partition hot and cold basic blocks into separate
1053      sections of the .o and executable files does not work (currently)
1054      with exception handling.  This is because there is no support for
1055      generating unwind info.  If flag_exceptions is turned on we need to
1056      turn off the partitioning optimization.  */
1057
1058   if (flag_exceptions && flag_reorder_blocks_and_partition
1059       && (USING_SJLJ_EXCEPTIONS
1060 #ifdef TARGET_UNWIND_INFO
1061           || 1
1062 #endif
1063          ))
1064     {
1065       inform (input_location,
1066               "-freorder-blocks-and-partition does not work with exceptions on this architecture");
1067       flag_reorder_blocks_and_partition = 0;
1068       flag_reorder_blocks = 1;
1069     }
1070
1071   /* If user requested unwind info, then turn off the partitioning
1072      optimization.  */
1073
1074   if (flag_unwind_tables && ! targetm.unwind_tables_default
1075       && flag_reorder_blocks_and_partition
1076       && (USING_SJLJ_EXCEPTIONS
1077 #ifdef TARGET_UNWIND_INFO
1078           || 1
1079 #endif
1080          ))
1081     {
1082       inform (input_location,
1083               "-freorder-blocks-and-partition does not support unwind info on this architecture");
1084       flag_reorder_blocks_and_partition = 0;
1085       flag_reorder_blocks = 1;
1086     }
1087
1088   /* If the target requested unwind info, then turn off the partitioning
1089      optimization with a different message.  Likewise, if the target does not
1090      support named sections.  */
1091
1092   if (flag_reorder_blocks_and_partition
1093       && (!targetm.have_named_sections
1094           || (flag_unwind_tables && targetm.unwind_tables_default
1095               && (USING_SJLJ_EXCEPTIONS
1096 #ifdef TARGET_UNWIND_INFO
1097                   || 1
1098 #endif
1099                  ))))
1100     {
1101       inform (input_location,
1102               "-freorder-blocks-and-partition does not work on this architecture");
1103       flag_reorder_blocks_and_partition = 0;
1104       flag_reorder_blocks = 1;
1105     }
1106
1107   /* Pipelining of outer loops is only possible when general pipelining
1108      capabilities are requested.  */
1109   if (!flag_sel_sched_pipelining)
1110     flag_sel_sched_pipelining_outer_loops = 0;
1111
1112   if (!targetm.ira_cover_classes
1113       && flag_ira_algorithm == IRA_ALGORITHM_CB)
1114     {
1115       inform (input_location,
1116               "-fira-algorithm=CB does not work on this architecture");
1117       flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1118     }
1119
1120   if (flag_conserve_stack)
1121     {
1122       if (!PARAM_SET_P (PARAM_LARGE_STACK_FRAME))
1123         PARAM_VALUE (PARAM_LARGE_STACK_FRAME) = 100;
1124       if (!PARAM_SET_P (PARAM_STACK_FRAME_GROWTH))
1125         PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) = 40;
1126     }
1127   if (flag_wpa || flag_ltrans)
1128     {
1129       /* These passes are not WHOPR compatible yet.  */
1130       flag_ipa_cp = 0;
1131       flag_ipa_reference = 0;
1132       flag_ipa_type_escape = 0;
1133       flag_ipa_pta = 0;
1134       flag_ipa_struct_reorg = 0;
1135     }
1136
1137   if (flag_lto || flag_whopr)
1138     {
1139 #ifdef ENABLE_LTO
1140       flag_generate_lto = 1;
1141
1142       /* When generating IL, do not operate in whole-program mode.
1143          Otherwise, symbols will be privatized too early, causing link
1144          errors later.  */
1145       flag_whole_program = 0;
1146 #else
1147       error ("LTO support has not been enabled in this configuration");
1148 #endif
1149     }
1150
1151   /* Reconcile -flto and -fwhopr.  Set additional flags as appropriate and
1152      check option consistency.  */
1153   if (flag_lto && flag_whopr)
1154     error ("-flto and -fwhopr are mutually exclusive");
1155 }
1156
1157 #define LEFT_COLUMN     27
1158
1159 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1160    followed by word-wrapped HELP in a second column.  */
1161 static void
1162 wrap_help (const char *help,
1163            const char *item,
1164            unsigned int item_width,
1165            unsigned int columns)
1166 {
1167   unsigned int col_width = LEFT_COLUMN;
1168   unsigned int remaining, room, len;
1169
1170   remaining = strlen (help);
1171
1172   do
1173     {
1174       room = columns - 3 - MAX (col_width, item_width);
1175       if (room > columns)
1176         room = 0;
1177       len = remaining;
1178
1179       if (room < len)
1180         {
1181           unsigned int i;
1182
1183           for (i = 0; help[i]; i++)
1184             {
1185               if (i >= room && len != remaining)
1186                 break;
1187               if (help[i] == ' ')
1188                 len = i;
1189               else if ((help[i] == '-' || help[i] == '/')
1190                        && help[i + 1] != ' '
1191                        && i > 0 && ISALPHA (help[i - 1]))
1192                 len = i + 1;
1193             }
1194         }
1195
1196       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1197       item_width = 0;
1198       while (help[len] == ' ')
1199         len++;
1200       help += len;
1201       remaining -= len;
1202     }
1203   while (remaining);
1204 }
1205
1206 /* Print help for a specific front-end, etc.  */
1207 static void
1208 print_filtered_help (unsigned int include_flags,
1209                      unsigned int exclude_flags,
1210                      unsigned int any_flags,
1211                      unsigned int columns)
1212 {
1213   unsigned int i;
1214   const char *help;
1215   static char *printed = NULL;
1216   bool found = false;
1217   bool displayed = false;
1218
1219   if (include_flags == CL_PARAMS)
1220     {
1221       for (i = 0; i < LAST_PARAM; i++)
1222         {
1223           const char *param = compiler_params[i].option;
1224
1225           help = compiler_params[i].help;
1226           if (help == NULL || *help == '\0')
1227             {
1228               if (exclude_flags & CL_UNDOCUMENTED)
1229                 continue;
1230               help = undocumented_msg;
1231             }
1232
1233           /* Get the translation.  */
1234           help = _(help);
1235
1236           wrap_help (help, param, strlen (param), columns);
1237         }
1238       putchar ('\n');
1239       return;
1240     }
1241
1242   if (!printed)
1243     printed = XCNEWVAR (char, cl_options_count);
1244
1245   for (i = 0; i < cl_options_count; i++)
1246     {
1247       static char new_help[128];
1248       const struct cl_option *option = cl_options + i;
1249       unsigned int len;
1250       const char *opt;
1251       const char *tab;
1252
1253       if (include_flags == 0
1254           || ((option->flags & include_flags) != include_flags))
1255         {
1256           if ((option->flags & any_flags) == 0)
1257             continue;
1258         }
1259
1260       /* Skip unwanted switches.  */
1261       if ((option->flags & exclude_flags) != 0)
1262         continue;
1263
1264       found = true;
1265       /* Skip switches that have already been printed.  */
1266       if (printed[i])
1267         continue;
1268
1269       printed[i] = true;
1270
1271       help = option->help;
1272       if (help == NULL)
1273         {
1274           if (exclude_flags & CL_UNDOCUMENTED)
1275             continue;
1276           help = undocumented_msg;
1277         }
1278
1279       /* Get the translation.  */
1280       help = _(help);
1281
1282       /* Find the gap between the name of the
1283          option and its descriptive text.  */
1284       tab = strchr (help, '\t');
1285       if (tab)
1286         {
1287           len = tab - help;
1288           opt = help;
1289           help = tab + 1;
1290         }
1291       else
1292         {
1293           opt = option->opt_text;
1294           len = strlen (opt);
1295         }
1296
1297       /* With the -Q option enabled we change the descriptive text associated
1298          with an option to be an indication of its current setting.  */
1299       if (!quiet_flag)
1300         {
1301           if (len < (LEFT_COLUMN + 2))
1302             strcpy (new_help, "\t\t");
1303           else
1304             strcpy (new_help, "\t");
1305
1306           if (option->flag_var != NULL)
1307             {
1308               if (option->flags & CL_JOINED)
1309                 {
1310                   if (option->var_type == CLVC_STRING)
1311                     {
1312                       if (* (const char **) option->flag_var != NULL)
1313                         snprintf (new_help + strlen (new_help),
1314                                   sizeof (new_help) - strlen (new_help),
1315                                   * (const char **) option->flag_var);
1316                     }
1317                   else
1318                     sprintf (new_help + strlen (new_help),
1319                              "%#x", * (int *) option->flag_var);
1320                 }
1321               else
1322                 strcat (new_help, option_enabled (i)
1323                         ? _("[enabled]") : _("[disabled]"));
1324             }
1325
1326           help = new_help;
1327         }
1328
1329       wrap_help (help, opt, len, columns);
1330       displayed = true;
1331     }
1332
1333   if (! found)
1334     {
1335       unsigned int langs = include_flags & CL_LANG_ALL;
1336
1337       if (langs == 0)
1338         printf (_(" No options with the desired characteristics were found\n"));
1339       else
1340         {
1341           unsigned int i;
1342
1343           /* PR 31349: Tell the user how to see all of the
1344              options supported by a specific front end.  */
1345           for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1346             if ((1U << i) & langs)
1347               printf (_(" None found.  Use --help=%s to show *all* the options supported by the %s front-end\n"),
1348                       lang_names[i], lang_names[i]);
1349         }
1350
1351     }
1352   else if (! displayed)
1353     printf (_(" All options with the desired characteristics have already been displayed\n"));
1354
1355   putchar ('\n');
1356 }
1357
1358 /* Display help for a specified type of option.
1359    The options must have ALL of the INCLUDE_FLAGS set
1360    ANY of the flags in the ANY_FLAGS set
1361    and NONE of the EXCLUDE_FLAGS set.  */
1362 static void
1363 print_specific_help (unsigned int include_flags,
1364                      unsigned int exclude_flags,
1365                      unsigned int any_flags)
1366 {
1367   unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1368   const char * description = NULL;
1369   const char * descrip_extra = "";
1370   size_t i;
1371   unsigned int flag;
1372   static unsigned int columns = 0;
1373
1374   /* Sanity check: Make sure that we do not have more
1375      languages than we have bits available to enumerate them.  */
1376   gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
1377
1378   /* If we have not done so already, obtain
1379      the desired maximum width of the output.  */
1380   if (columns == 0)
1381     {
1382       const char *p;
1383
1384       GET_ENVIRONMENT (p, "COLUMNS");
1385       if (p != NULL)
1386         {
1387           int value = atoi (p);
1388
1389           if (value > 0)
1390             columns = value;
1391         }
1392
1393       if (columns == 0)
1394         /* Use a reasonable default.  */
1395         columns = 80;
1396     }
1397
1398   /* Decide upon the title for the options that we are going to display.  */
1399   for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1400     {
1401       switch (flag & include_flags)
1402         {
1403         case 0:
1404           break;
1405
1406         case CL_TARGET:
1407           description = _("The following options are target specific");
1408           break;
1409         case CL_WARNING:
1410           description = _("The following options control compiler warning messages");
1411           break;
1412         case CL_OPTIMIZATION:
1413           description = _("The following options control optimizations");
1414           break;
1415         case CL_COMMON:
1416           description = _("The following options are language-independent");
1417           break;
1418         case CL_PARAMS:
1419           description = _("The --param option recognizes the following as parameters");
1420           break;
1421         default:
1422           if (i >= cl_lang_count)
1423             break;
1424           if (exclude_flags & all_langs_mask)
1425             description = _("The following options are specific to just the language ");
1426           else
1427             description = _("The following options are supported by the language ");
1428           descrip_extra = lang_names [i];
1429           break;
1430         }
1431     }
1432
1433   if (description == NULL)
1434     {
1435       if (any_flags == 0)
1436         {
1437           if (include_flags & CL_UNDOCUMENTED)
1438             description = _("The following options are not documented");
1439           else if (include_flags & CL_SEPARATE)
1440             description = _("The following options take separate arguments");
1441           else if (include_flags & CL_JOINED)
1442             description = _("The following options take joined arguments");
1443           else
1444             {
1445               internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1446                               include_flags);
1447               return;
1448             }
1449         }
1450       else
1451         {
1452           if (any_flags & all_langs_mask)
1453             description = _("The following options are language-related");
1454           else
1455             description = _("The following options are language-independent");
1456         }
1457     }
1458
1459   printf ("%s%s:\n", description, descrip_extra);
1460   print_filtered_help (include_flags, exclude_flags, any_flags, columns);
1461 }
1462
1463 /* Handle target- and language-independent options.  Return zero to
1464    generate an "unknown option" message.  Only options that need
1465    extra handling need to be listed here; if you simply want
1466    VALUE assigned to a variable, it happens automatically.  */
1467
1468 static int
1469 common_handle_option (size_t scode, const char *arg, int value,
1470                       unsigned int lang_mask)
1471 {
1472   static bool verbose = false;
1473   enum opt_code code = (enum opt_code) scode;
1474
1475   switch (code)
1476     {
1477     case OPT__param:
1478       handle_param (arg);
1479       break;
1480
1481     case OPT_v:
1482       verbose = true;
1483       break;
1484
1485     case OPT_fhelp:
1486     case OPT__help:
1487       {
1488         unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1489         unsigned int undoc_mask;
1490         unsigned int i;
1491
1492         undoc_mask = (verbose | extra_warnings) ? 0 : CL_UNDOCUMENTED;
1493         /* First display any single language specific options.  */
1494         for (i = 0; i < cl_lang_count; i++)
1495           print_specific_help
1496             (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0);
1497         /* Next display any multi language specific options.  */
1498         print_specific_help (0, undoc_mask, all_langs_mask);
1499         /* Then display any remaining, non-language options.  */
1500         for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1501           print_specific_help (i, undoc_mask, 0);
1502         exit_after_options = true;
1503         break;
1504       }
1505
1506     case OPT_ftarget_help:
1507     case OPT__target_help:
1508       print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0);
1509       exit_after_options = true;
1510
1511       /* Allow the target a chance to give the user some additional information.  */
1512       if (targetm.target_help)
1513         targetm.target_help ();
1514       break;
1515
1516     case OPT_fhelp_:
1517     case OPT__help_:
1518       {
1519         const char * a = arg;
1520         unsigned int include_flags = 0;
1521         /* Note - by default we include undocumented options when listing
1522            specific classes.  If you only want to see documented options
1523            then add ",^undocumented" to the --help= option.  E.g.:
1524
1525            --help=target,^undocumented  */
1526         unsigned int exclude_flags = 0;
1527
1528         /* Walk along the argument string, parsing each word in turn.
1529            The format is:
1530            arg = [^]{word}[,{arg}]
1531            word = {optimizers|target|warnings|undocumented|
1532                    params|common|<language>}  */
1533         while (* a != 0)
1534           {
1535             static struct
1536             {
1537               const char * string;
1538               unsigned int flag;
1539             }
1540             specifics[] =
1541             {
1542               { "optimizers", CL_OPTIMIZATION },
1543               { "target", CL_TARGET },
1544               { "warnings", CL_WARNING },
1545               { "undocumented", CL_UNDOCUMENTED },
1546               { "params", CL_PARAMS },
1547               { "joined", CL_JOINED },
1548               { "separate", CL_SEPARATE },
1549               { "common", CL_COMMON },
1550               { NULL, 0 }
1551             };
1552             unsigned int * pflags;
1553             const char * comma;
1554             unsigned int lang_flag, specific_flag;
1555             unsigned int len;
1556             unsigned int i;
1557
1558             if (* a == '^')
1559               {
1560                 ++ a;
1561                 pflags = & exclude_flags;
1562               }
1563             else
1564               pflags = & include_flags;
1565
1566             comma = strchr (a, ',');
1567             if (comma == NULL)
1568               len = strlen (a);
1569             else
1570               len = comma - a;
1571             if (len == 0)
1572               {
1573                 a = comma + 1;
1574                 continue;
1575               }
1576
1577             /* Check to see if the string matches an option class name.  */
1578             for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1579               if (strncasecmp (a, specifics[i].string, len) == 0)
1580                 {
1581                   specific_flag = specifics[i].flag;
1582                   break;
1583                 }
1584
1585             /* Check to see if the string matches a language name.
1586                Note - we rely upon the alpha-sorted nature of the entries in
1587                the lang_names array, specifically that shorter names appear
1588                before their longer variants.  (i.e. C before C++).  That way
1589                when we are attempting to match --help=c for example we will
1590                match with C first and not C++.  */
1591             for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1592               if (strncasecmp (a, lang_names[i], len) == 0)
1593                 {
1594                   lang_flag = 1U << i;
1595                   break;
1596                 }
1597
1598             if (specific_flag != 0)
1599               {
1600                 if (lang_flag == 0)
1601                   * pflags |= specific_flag;
1602                 else
1603                   {
1604                     /* The option's argument matches both the start of a
1605                        language name and the start of an option class name.
1606                        We have a special case for when the user has
1607                        specified "--help=c", but otherwise we have to issue
1608                        a warning.  */
1609                     if (strncasecmp (a, "c", len) == 0)
1610                       * pflags |= lang_flag;
1611                     else
1612                       fnotice (stderr,
1613                                "warning: --help argument %.*s is ambiguous, please be more specific\n",
1614                                len, a);
1615                   }
1616               }
1617             else if (lang_flag != 0)
1618               * pflags |= lang_flag;
1619             else
1620               fnotice (stderr,
1621                        "warning: unrecognized argument to --help= option: %.*s\n",
1622                        len, a);
1623
1624             if (comma == NULL)
1625               break;
1626             a = comma + 1;
1627           }
1628
1629         if (include_flags)
1630           print_specific_help (include_flags, exclude_flags, 0);
1631         exit_after_options = true;
1632         break;
1633       }
1634
1635     case OPT_fversion:
1636     case OPT__version:
1637       exit_after_options = true;
1638       break;
1639
1640     case OPT_G:
1641       g_switch_value = value;
1642       g_switch_set = true;
1643       break;
1644
1645     case OPT_O:
1646     case OPT_Os:
1647       /* Currently handled in a prescan.  */
1648       break;
1649
1650     case OPT_Werror_:
1651       enable_warning_as_error (arg, value, lang_mask);
1652       break;
1653
1654     case OPT_Wlarger_than_:
1655       /* This form corresponds to -Wlarger-than-.
1656          Kept for backward compatibility.
1657          Don't use it as the first argument of warning().  */
1658
1659     case OPT_Wlarger_than_eq:
1660       larger_than_size = value;
1661       warn_larger_than = value != -1;
1662       break;
1663
1664     case OPT_Wframe_larger_than_:
1665       frame_larger_than_size = value;
1666       warn_frame_larger_than = value != -1;
1667       break;
1668
1669     case OPT_Wstrict_aliasing:
1670       set_Wstrict_aliasing (value);
1671       break;
1672
1673     case OPT_Wstrict_aliasing_:
1674       warn_strict_aliasing = value;
1675       break;
1676
1677     case OPT_Wstrict_overflow:
1678       warn_strict_overflow = (value
1679                               ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1680                               : 0);
1681       break;
1682
1683     case OPT_Wstrict_overflow_:
1684       warn_strict_overflow = value;
1685       break;
1686
1687     case OPT_Wunused:
1688       warn_unused = value;
1689       break;
1690
1691     case OPT_aux_info:
1692     case OPT_aux_info_:
1693       aux_info_file_name = arg;
1694       flag_gen_aux_info = 1;
1695       break;
1696
1697     case OPT_auxbase:
1698       aux_base_name = arg;
1699       break;
1700
1701     case OPT_auxbase_strip:
1702       {
1703         char *tmp = xstrdup (arg);
1704         strip_off_ending (tmp, strlen (tmp));
1705         if (tmp[0])
1706           aux_base_name = tmp;
1707       }
1708       break;
1709
1710     case OPT_d:
1711       decode_d_option (arg);
1712       break;
1713
1714     case OPT_dumpbase:
1715       dump_base_name = arg;
1716       break;
1717
1718     case OPT_dumpdir:
1719       dump_dir_name = arg;
1720       break;
1721
1722     case OPT_falign_functions_:
1723       align_functions = value;
1724       break;
1725
1726     case OPT_falign_jumps_:
1727       align_jumps = value;
1728       break;
1729
1730     case OPT_falign_labels_:
1731       align_labels = value;
1732       break;
1733
1734     case OPT_falign_loops_:
1735       align_loops = value;
1736       break;
1737
1738     case OPT_fbranch_probabilities:
1739       flag_branch_probabilities_set = true;
1740       break;
1741
1742     case OPT_fcall_used_:
1743       fix_register (arg, 0, 1);
1744       break;
1745
1746     case OPT_fcall_saved_:
1747       fix_register (arg, 0, 0);
1748       break;
1749
1750     case OPT_fdbg_cnt_:
1751       dbg_cnt_process_opt (arg);
1752       break;
1753
1754     case OPT_fdbg_cnt_list:
1755       dbg_cnt_list_all_counters ();
1756       break;
1757
1758     case OPT_fdebug_prefix_map_:
1759       add_debug_prefix_map (arg);
1760       break;
1761
1762     case OPT_fdiagnostics_show_location_:
1763       if (!strcmp (arg, "once"))
1764         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
1765       else if (!strcmp (arg, "every-line"))
1766         diagnostic_prefixing_rule (global_dc)
1767           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
1768       else
1769         return 0;
1770       break;
1771
1772     case OPT_fdiagnostics_show_option:
1773       global_dc->show_option_requested = value;
1774       break;
1775
1776     case OPT_fdump_:
1777       if (!dump_switch_p (arg))
1778         return 0;
1779       break;
1780
1781     case OPT_fexcess_precision_:
1782       if (!strcmp (arg, "fast"))
1783         flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
1784       else if (!strcmp (arg, "standard"))
1785         flag_excess_precision_cmdline = EXCESS_PRECISION_STANDARD;
1786       else
1787         error ("unknown excess precision style \"%s\"", arg);
1788       break;
1789
1790     case OPT_ffast_math:
1791       set_fast_math_flags (value);
1792       break;
1793
1794     case OPT_funsafe_math_optimizations:
1795       set_unsafe_math_optimizations_flags (value);
1796       break;
1797
1798     case OPT_ffixed_:
1799       fix_register (arg, 1, 1);
1800       break;
1801
1802     case OPT_finline_limit_:
1803     case OPT_finline_limit_eq:
1804       set_param_value ("max-inline-insns-single", value / 2);
1805       set_param_value ("max-inline-insns-auto", value / 2);
1806       break;
1807
1808     case OPT_finstrument_functions_exclude_function_list_:
1809       add_comma_separated_to_vector
1810         (&flag_instrument_functions_exclude_functions, arg);
1811       break;
1812
1813     case OPT_finstrument_functions_exclude_file_list_:
1814       add_comma_separated_to_vector
1815         (&flag_instrument_functions_exclude_files, arg);
1816       break;
1817
1818     case OPT_fmessage_length_:
1819       pp_set_line_maximum_length (global_dc->printer, value);
1820       break;
1821
1822     case OPT_fpack_struct_:
1823       if (value <= 0 || (value & (value - 1)) || value > 16)
1824         error ("structure alignment must be a small power of two, not %d", value);
1825       else
1826         {
1827           initial_max_fld_align = value;
1828           maximum_field_alignment = value * BITS_PER_UNIT;
1829         }
1830       break;
1831
1832     case OPT_fpeel_loops:
1833       flag_peel_loops_set = true;
1834       break;
1835
1836     case OPT_fplugin_:
1837 #ifdef ENABLE_PLUGIN
1838       add_new_plugin (arg);
1839 #else
1840       error ("Plugin support is disabled.  Configure with --enable-plugin.");
1841 #endif
1842       break;
1843
1844     case OPT_fplugin_arg_:
1845 #ifdef ENABLE_PLUGIN
1846       parse_plugin_arg_opt (arg);
1847 #else
1848       error ("Plugin support is disabled.  Configure with --enable-plugin.");
1849 #endif
1850       break;
1851
1852     case OPT_fprofile_arcs:
1853       profile_arc_flag_set = true;
1854       break;
1855
1856     case OPT_finline_functions:
1857       flag_inline_functions_set = true;
1858       break;
1859
1860     case OPT_fprofile_dir_:
1861       profile_data_prefix = xstrdup (arg);
1862       break;
1863
1864     case OPT_fprofile_use_:
1865       profile_data_prefix = xstrdup (arg);
1866       flag_profile_use = true;
1867       value = true;
1868       /* No break here - do -fprofile-use processing. */
1869     case OPT_fprofile_use:
1870       if (!flag_branch_probabilities_set)
1871         flag_branch_probabilities = value;
1872       if (!flag_profile_values_set)
1873         flag_profile_values = value;
1874       if (!flag_unroll_loops_set)
1875         flag_unroll_loops = value;
1876       if (!flag_peel_loops_set)
1877         flag_peel_loops = value;
1878       if (!flag_tracer_set)
1879         flag_tracer = value;
1880       if (!flag_value_profile_transformations_set)
1881         flag_value_profile_transformations = value;
1882       if (!flag_inline_functions_set)
1883         flag_inline_functions = value;
1884       if (!flag_ipa_cp_set)
1885         flag_ipa_cp = value;
1886       if (!flag_ipa_cp_clone_set
1887           && value && flag_ipa_cp)
1888         flag_ipa_cp_clone = value;
1889       if (!flag_predictive_commoning_set)
1890         flag_predictive_commoning = value;
1891       if (!flag_unswitch_loops_set)
1892         flag_unswitch_loops = value;
1893       if (!flag_gcse_after_reload_set)
1894         flag_gcse_after_reload = value;
1895       break;
1896
1897     case OPT_fprofile_generate_:
1898       profile_data_prefix = xstrdup (arg);
1899       value = true;
1900       /* No break here - do -fprofile-generate processing. */
1901     case OPT_fprofile_generate:
1902       if (!profile_arc_flag_set)
1903         profile_arc_flag = value;
1904       if (!flag_profile_values_set)
1905         flag_profile_values = value;
1906       if (!flag_value_profile_transformations_set)
1907         flag_value_profile_transformations = value;
1908       if (!flag_inline_functions_set)
1909         flag_inline_functions = value;
1910       break;
1911
1912     case OPT_fprofile_values:
1913       flag_profile_values_set = true;
1914       break;
1915
1916     case OPT_fvisibility_:
1917       {
1918         if (!strcmp(arg, "default"))
1919           default_visibility = VISIBILITY_DEFAULT;
1920         else if (!strcmp(arg, "internal"))
1921           default_visibility = VISIBILITY_INTERNAL;
1922         else if (!strcmp(arg, "hidden"))
1923           default_visibility = VISIBILITY_HIDDEN;
1924         else if (!strcmp(arg, "protected"))
1925           default_visibility = VISIBILITY_PROTECTED;
1926         else
1927           error ("unrecognized visibility value \"%s\"", arg);
1928       }
1929       break;
1930
1931     case OPT_fvpt:
1932       flag_value_profile_transformations_set = true;
1933       break;
1934
1935     case OPT_frandom_seed:
1936       /* The real switch is -fno-random-seed.  */
1937       if (value)
1938         return 0;
1939       set_random_seed (NULL);
1940       break;
1941
1942     case OPT_frandom_seed_:
1943       set_random_seed (arg);
1944       break;
1945
1946     case OPT_fselective_scheduling:
1947     case OPT_fselective_scheduling2:
1948       sel_sched_switch_set = true;
1949       break;
1950
1951     case OPT_fsched_verbose_:
1952 #ifdef INSN_SCHEDULING
1953       fix_sched_param ("verbose", arg);
1954       break;
1955 #else
1956       return 0;
1957 #endif
1958
1959     case OPT_fsched_stalled_insns_:
1960       flag_sched_stalled_insns = value;
1961       if (flag_sched_stalled_insns == 0)
1962         flag_sched_stalled_insns = -1;
1963       break;
1964
1965     case OPT_fsched_stalled_insns_dep_:
1966       flag_sched_stalled_insns_dep = value;
1967       break;
1968
1969     case OPT_fstack_check_:
1970       if (!strcmp (arg, "no"))
1971         flag_stack_check = NO_STACK_CHECK;
1972       else if (!strcmp (arg, "generic"))
1973         /* This is the old stack checking method.  */
1974         flag_stack_check = STACK_CHECK_BUILTIN
1975                            ? FULL_BUILTIN_STACK_CHECK
1976                            : GENERIC_STACK_CHECK;
1977       else if (!strcmp (arg, "specific"))
1978         /* This is the new stack checking method.  */
1979         flag_stack_check = STACK_CHECK_BUILTIN
1980                            ? FULL_BUILTIN_STACK_CHECK
1981                            : STACK_CHECK_STATIC_BUILTIN
1982                              ? STATIC_BUILTIN_STACK_CHECK
1983                              : GENERIC_STACK_CHECK;
1984       else
1985         warning (0, "unknown stack check parameter \"%s\"", arg);
1986       break;
1987
1988     case OPT_fstack_check:
1989       /* This is the same as the "specific" mode above.  */
1990       if (value)
1991         flag_stack_check = STACK_CHECK_BUILTIN
1992                            ? FULL_BUILTIN_STACK_CHECK
1993                            : STACK_CHECK_STATIC_BUILTIN
1994                              ? STATIC_BUILTIN_STACK_CHECK
1995                              : GENERIC_STACK_CHECK;
1996       else
1997         flag_stack_check = NO_STACK_CHECK;
1998       break;
1999
2000     case OPT_fstack_limit:
2001       /* The real switch is -fno-stack-limit.  */
2002       if (value)
2003         return 0;
2004       stack_limit_rtx = NULL_RTX;
2005       break;
2006
2007     case OPT_fstack_limit_register_:
2008       {
2009         int reg = decode_reg_name (arg);
2010         if (reg < 0)
2011           error ("unrecognized register name \"%s\"", arg);
2012         else
2013           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
2014       }
2015       break;
2016
2017     case OPT_fstack_limit_symbol_:
2018       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
2019       break;
2020
2021     case OPT_ftree_vectorizer_verbose_:
2022       vect_set_verbosity_level (arg);
2023       break;
2024
2025     case OPT_ftls_model_:
2026       if (!strcmp (arg, "global-dynamic"))
2027         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
2028       else if (!strcmp (arg, "local-dynamic"))
2029         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
2030       else if (!strcmp (arg, "initial-exec"))
2031         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
2032       else if (!strcmp (arg, "local-exec"))
2033         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
2034       else
2035         warning (0, "unknown tls-model \"%s\"", arg);
2036       break;
2037
2038     case OPT_fira_algorithm_:
2039       if (!strcmp (arg, "CB"))
2040         flag_ira_algorithm = IRA_ALGORITHM_CB;
2041       else if (!strcmp (arg, "priority"))
2042         flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
2043       else
2044         warning (0, "unknown ira algorithm \"%s\"", arg);
2045       break;
2046
2047     case OPT_fira_region_:
2048       if (!strcmp (arg, "one"))
2049         flag_ira_region = IRA_REGION_ONE;
2050       else if (!strcmp (arg, "all"))
2051         flag_ira_region = IRA_REGION_ALL;
2052       else if (!strcmp (arg, "mixed"))
2053         flag_ira_region = IRA_REGION_MIXED;
2054       else
2055         warning (0, "unknown ira region \"%s\"", arg);
2056       break;
2057
2058     case OPT_fira_verbose_:
2059       flag_ira_verbose = value;
2060       break;
2061
2062     case OPT_ftracer:
2063       flag_tracer_set = true;
2064       break;
2065
2066     case OPT_fipa_cp:
2067       flag_ipa_cp_set = true;
2068       break;
2069
2070     case OPT_fipa_cp_clone:
2071       flag_ipa_cp_clone_set = true;
2072       break;
2073
2074     case OPT_fpredictive_commoning:
2075       flag_predictive_commoning_set = true;
2076       break;
2077
2078     case OPT_funswitch_loops:
2079       flag_unswitch_loops_set = true;
2080       break;
2081
2082     case OPT_fgcse_after_reload:
2083       flag_gcse_after_reload_set = true;
2084       break;
2085
2086     case OPT_funroll_loops:
2087       flag_unroll_loops_set = true;
2088       break;
2089
2090     case OPT_g:
2091       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
2092       break;
2093
2094     case OPT_gcoff:
2095       set_debug_level (SDB_DEBUG, false, arg);
2096       break;
2097
2098     case OPT_gdwarf_:
2099       if (value < 2 || value > 4)
2100         error ("dwarf version %d is not supported", value);
2101       else
2102         dwarf_version = value;
2103       set_debug_level (DWARF2_DEBUG, false, "");
2104       break;
2105
2106     case OPT_ggdb:
2107       set_debug_level (NO_DEBUG, 2, arg);
2108       break;
2109
2110     case OPT_gstabs:
2111     case OPT_gstabs_:
2112       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
2113       break;
2114
2115     case OPT_gvms:
2116       set_debug_level (VMS_DEBUG, false, arg);
2117       break;
2118
2119     case OPT_gxcoff:
2120     case OPT_gxcoff_:
2121       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
2122       break;
2123
2124     case OPT_o:
2125       asm_file_name = arg;
2126       break;
2127
2128     case OPT_pedantic_errors:
2129       flag_pedantic_errors = pedantic = 1;
2130       break;
2131
2132     case OPT_fsee:
2133     case OPT_fcse_skip_blocks:
2134     case OPT_floop_optimize:
2135     case OPT_frerun_loop_opt:
2136     case OPT_fsched2_use_traces:
2137     case OPT_fstrength_reduce:
2138     case OPT_ftree_store_copy_prop:
2139     case OPT_fforce_addr:
2140     case OPT_ftree_salias:
2141     case OPT_ftree_store_ccp:
2142     case OPT_Wunreachable_code:
2143     case OPT_fargument_alias:
2144     case OPT_fargument_noalias:
2145     case OPT_fargument_noalias_anything:
2146     case OPT_fargument_noalias_global:
2147       /* These are no-ops, preserved for backward compatibility.  */
2148       break;
2149
2150     case OPT_fuse_linker_plugin:
2151       /* No-op. Used by the driver and passed to us because it starts with f.*/
2152       break;
2153
2154     default:
2155       /* If the flag was handled in a standard way, assume the lack of
2156          processing here is intentional.  */
2157       gcc_assert (cl_options[scode].flag_var);
2158       break;
2159     }
2160
2161   return 1;
2162 }
2163
2164 /* Handle --param NAME=VALUE.  */
2165 static void
2166 handle_param (const char *carg)
2167 {
2168   char *equal, *arg;
2169   int value;
2170
2171   arg = xstrdup (carg);
2172   equal = strchr (arg, '=');
2173   if (!equal)
2174     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
2175   else
2176     {
2177       value = integral_argument (equal + 1);
2178       if (value == -1)
2179         error ("invalid --param value %qs", equal + 1);
2180       else
2181         {
2182           *equal = '\0';
2183           set_param_value (arg, value);
2184         }
2185     }
2186
2187   free (arg);
2188 }
2189
2190 /* Used to set the level of strict aliasing warnings,
2191    when no level is specified (i.e., when -Wstrict-aliasing, and not
2192    -Wstrict-aliasing=level was given).
2193    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2194    and 0 otherwise.  After calling this function, wstrict_aliasing will be
2195    set to the default value of -Wstrict_aliasing=level, currently 3.  */
2196 void
2197 set_Wstrict_aliasing (int onoff)
2198 {
2199   gcc_assert (onoff == 0 || onoff == 1);
2200   if (onoff != 0)
2201     warn_strict_aliasing = 3;
2202   else
2203     warn_strict_aliasing = 0;
2204 }
2205
2206 /* The following routines are useful in setting all the flags that
2207    -ffast-math and -fno-fast-math imply.  */
2208 void
2209 set_fast_math_flags (int set)
2210 {
2211   flag_unsafe_math_optimizations = set;
2212   set_unsafe_math_optimizations_flags (set);
2213   flag_finite_math_only = set;
2214   flag_errno_math = !set;
2215   if (set)
2216     {
2217       flag_signaling_nans = 0;
2218       flag_rounding_math = 0;
2219       flag_cx_limited_range = 1;
2220     }
2221 }
2222
2223 /* When -funsafe-math-optimizations is set the following
2224    flags are set as well.  */
2225 void
2226 set_unsafe_math_optimizations_flags (int set)
2227 {
2228   flag_trapping_math = !set;
2229   flag_signed_zeros = !set;
2230   flag_associative_math = set;
2231   flag_reciprocal_math = set;
2232 }
2233
2234 /* Return true iff flags are set as if -ffast-math.  */
2235 bool
2236 fast_math_flags_set_p (void)
2237 {
2238   return (!flag_trapping_math
2239           && flag_unsafe_math_optimizations
2240           && flag_finite_math_only
2241           && !flag_signed_zeros
2242           && !flag_errno_math);
2243 }
2244
2245 /* Return true iff flags are set as if -ffast-math but using the flags stored
2246    in the struct cl_optimization structure.  */
2247 bool
2248 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2249 {
2250   return (!opt->flag_trapping_math
2251           && opt->flag_unsafe_math_optimizations
2252           && opt->flag_finite_math_only
2253           && !opt->flag_signed_zeros
2254           && !opt->flag_errno_math);
2255 }
2256
2257 /* Handle a debug output -g switch.  EXTENDED is true or false to support
2258    extended output (2 is special and means "-ggdb" was given).  */
2259 static void
2260 set_debug_level (enum debug_info_type type, int extended, const char *arg)
2261 {
2262   static bool type_explicit;
2263
2264   use_gnu_debug_info_extensions = extended;
2265
2266   if (type == NO_DEBUG)
2267     {
2268       if (write_symbols == NO_DEBUG)
2269         {
2270           write_symbols = PREFERRED_DEBUGGING_TYPE;
2271
2272           if (extended == 2)
2273             {
2274 #ifdef DWARF2_DEBUGGING_INFO
2275               write_symbols = DWARF2_DEBUG;
2276 #elif defined DBX_DEBUGGING_INFO
2277               write_symbols = DBX_DEBUG;
2278 #endif
2279             }
2280
2281           if (write_symbols == NO_DEBUG)
2282             warning (0, "target system does not support debug output");
2283         }
2284     }
2285   else
2286     {
2287       /* Does it conflict with an already selected type?  */
2288       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
2289         error ("debug format \"%s\" conflicts with prior selection",
2290                debug_type_names[type]);
2291       write_symbols = type;
2292       type_explicit = true;
2293     }
2294
2295   /* A debug flag without a level defaults to level 2.  */
2296   if (*arg == '\0')
2297     {
2298       if (!debug_info_level)
2299         debug_info_level = DINFO_LEVEL_NORMAL;
2300     }
2301   else
2302     {
2303       int argval = integral_argument (arg);
2304       if (argval == -1)
2305         error ("unrecognised debug output level \"%s\"", arg);
2306       else if (argval > 3)
2307         error ("debug output level %s is too high", arg);
2308       else
2309         debug_info_level = (enum debug_info_level) argval;
2310     }
2311 }
2312
2313 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
2314    a simple on-off switch.  */
2315
2316 int
2317 option_enabled (int opt_idx)
2318 {
2319   const struct cl_option *option = &(cl_options[opt_idx]);
2320
2321   if (option->flag_var)
2322     switch (option->var_type)
2323       {
2324       case CLVC_BOOLEAN:
2325         return *(int *) option->flag_var != 0;
2326
2327       case CLVC_EQUAL:
2328         return *(int *) option->flag_var == option->var_value;
2329
2330       case CLVC_BIT_CLEAR:
2331         return (*(int *) option->flag_var & option->var_value) == 0;
2332
2333       case CLVC_BIT_SET:
2334         return (*(int *) option->flag_var & option->var_value) != 0;
2335
2336       case CLVC_STRING:
2337         break;
2338       }
2339   return -1;
2340 }
2341
2342 /* Fill STATE with the current state of option OPTION.  Return true if
2343    there is some state to store.  */
2344
2345 bool
2346 get_option_state (int option, struct cl_option_state *state)
2347 {
2348   if (cl_options[option].flag_var == 0)
2349     return false;
2350
2351   switch (cl_options[option].var_type)
2352     {
2353     case CLVC_BOOLEAN:
2354     case CLVC_EQUAL:
2355       state->data = cl_options[option].flag_var;
2356       state->size = sizeof (int);
2357       break;
2358
2359     case CLVC_BIT_CLEAR:
2360     case CLVC_BIT_SET:
2361       state->ch = option_enabled (option);
2362       state->data = &state->ch;
2363       state->size = 1;
2364       break;
2365
2366     case CLVC_STRING:
2367       state->data = *(const char **) cl_options[option].flag_var;
2368       if (state->data == 0)
2369         state->data = "";
2370       state->size = strlen ((const char *) state->data) + 1;
2371       break;
2372     }
2373   return true;
2374 }
2375
2376 /* Set *OPTION according to VALUE and ARG.  */
2377
2378 void
2379 set_option (const struct cl_option *option, int value, const char *arg)
2380 {
2381   if (!option->flag_var)
2382     return;
2383
2384   switch (option->var_type)
2385     {
2386     case CLVC_BOOLEAN:
2387         *(int *) option->flag_var = value;
2388         break;
2389
2390     case CLVC_EQUAL:
2391         *(int *) option->flag_var = (value
2392                                      ? option->var_value
2393                                      : !option->var_value);
2394         break;
2395
2396     case CLVC_BIT_CLEAR:
2397     case CLVC_BIT_SET:
2398         if ((value != 0) == (option->var_type == CLVC_BIT_SET))
2399           *(int *) option->flag_var |= option->var_value;
2400         else
2401           *(int *) option->flag_var &= ~option->var_value;
2402         if (option->flag_var == &target_flags)
2403           target_flags_explicit |= option->var_value;
2404         break;
2405
2406     case CLVC_STRING:
2407         *(const char **) option->flag_var = arg;
2408         break;
2409     }
2410 }
2411
2412
2413 /* Callback function, called when -Werror= enables a warning.  */
2414
2415 static void (*warning_as_error_callback) (int) = NULL;
2416
2417 /* Register a callback for enable_warning_as_error calls.  */
2418
2419 void
2420 register_warning_as_error_callback (void (*callback) (int))
2421 {
2422   gcc_assert (warning_as_error_callback == NULL || callback == NULL);
2423   warning_as_error_callback = callback;
2424 }
2425
2426 /* Enable a warning option as an error.  This is used by -Werror= and
2427    also by legacy Werror-implicit-function-declaration.  */
2428
2429 void
2430 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask)
2431 {
2432   char *new_option;
2433   int option_index;
2434
2435   new_option = XNEWVEC (char, strlen (arg) + 2);
2436   new_option[0] = 'W';
2437   strcpy (new_option + 1, arg);
2438   option_index = find_opt (new_option, lang_mask);
2439   if (option_index == N_OPTS)
2440     {
2441       error ("-Werror=%s: No option -%s", arg, new_option);
2442     }
2443   else
2444     {
2445       const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
2446
2447       diagnostic_classify_diagnostic (global_dc, option_index, kind);
2448       if (kind == DK_ERROR)
2449         {
2450           const struct cl_option * const option = cl_options + option_index;
2451
2452           /* -Werror=foo implies -Wfoo.  */
2453           if (option->var_type == CLVC_BOOLEAN && option->flag_var)
2454             *(int *) option->flag_var = 1;
2455
2456           if (warning_as_error_callback)
2457             warning_as_error_callback (option_index);
2458         }
2459     }
2460   free (new_option);
2461 }