gcc/opts.c

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