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
  46 /* Value of the -G xx switch, and whether it was passed or not.  */
  47 unsigned HOST_WIDE_INT g_switch_value;
  48 bool g_switch_set;
  49
  50 /* Same for selective scheduling.  */
  51 bool sel_sched_switch_set;
  52
  53 /* True if we should exit after parsing options.  */
  54 bool exit_after_options;
  55
  56 /* Print various extra warnings.  -W/-Wextra.  */
  57 bool extra_warnings;
  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 #ifdef ENABLE_CHECKING
 342 static const char undocumented_msg[] = N_("This switch lacks documentation");
 343 #else
 344 static const char undocumented_msg[] = "";
 345 #endif
 346
 347 /* Used for bookkeeping on whether user set these flags so
 348    -fprofile-use/-fprofile-generate does not use them.  */
 349 static bool profile_arc_flag_set, flag_profile_values_set;
 350 static bool flag_unroll_loops_set, flag_tracer_set;
 351 static bool flag_value_profile_transformations_set;
 352 static bool flag_peel_loops_set, flag_branch_probabilities_set;
 353 static bool flag_inline_functions_set, flag_ipa_cp_set, flag_ipa_cp_clone_set;
 354 static bool flag_predictive_commoning_set, flag_unswitch_loops_set, flag_gcse_after_reload_set;
 355
 356 /* Functions excluded from profiling.  */
 357
 358 typedef char *char_p; /* For DEF_VEC_P.  */
 359 DEF_VEC_P(char_p);
 360 DEF_VEC_ALLOC_P(char_p,heap);
 361
 362 static VEC(char_p,heap) *flag_instrument_functions_exclude_functions;
 363 static VEC(char_p,heap) *flag_instrument_functions_exclude_files;
 364
 365 typedef const char *const_char_p; /* For DEF_VEC_P.  */
 366 DEF_VEC_P(const_char_p);
 367 DEF_VEC_ALLOC_P(const_char_p,heap);
 368
 369 static VEC(const_char_p,heap) *ignored_options;
 370
 371 /* Input file names.  */
 372 const char **in_fnames;
 373 unsigned num_in_fnames;
 374
 375 static int common_handle_option (size_t scode, const char *arg, int value,
 376                                  unsigned int lang_mask);
 377 static void handle_param (const char *);
 378 static void set_Wextra (int);
 379 static unsigned int handle_option (const char **argv, unsigned int lang_mask);
 380 static char *write_langs (unsigned int lang_mask);
 381 static void complain_wrong_lang (const char *, const struct cl_option *,
 382                                  unsigned int lang_mask);
 383 static void handle_options (unsigned int, const char **, unsigned int);
 384 static void set_debug_level (enum debug_info_type type, int extended,
 385                              const char *arg);
 386
 387 /* If ARG is a non-negative integer made up solely of digits, return its
 388    value, otherwise return -1.  */
 389 static int
 390 integral_argument (const char *arg)
 391 {
 392   const char *p = arg;
 393
 394   while (*p && ISDIGIT (*p))
 395     p++;
 396
 397   if (*p == '\0')
 398     return atoi (arg);
 399
 400   return -1;
 401 }
 402
 403 /* Return a malloced slash-separated list of languages in MASK.  */
 404 static char *
 405 write_langs (unsigned int mask)
 406 {
 407   unsigned int n = 0, len = 0;
 408   const char *lang_name;
 409   char *result;
 410
 411   for (n = 0; (lang_name = lang_names[n]) != 0; n++)
 412     if (mask & (1U << n))
 413       len += strlen (lang_name) + 1;
 414
 415   result = XNEWVEC (char, len);
 416   len = 0;
 417   for (n = 0; (lang_name = lang_names[n]) != 0; n++)
 418     if (mask & (1U << n))
 419       {
 420         if (len)
 421           result[len++] = '/';
 422         strcpy (result + len, lang_name);
 423         len += strlen (lang_name);
 424       }
 425
 426   result[len] = 0;
 427
 428   return result;
 429 }
 430
 431 /* Complain that switch OPT_INDEX does not apply to this front end.  */
 432 static void
 433 complain_wrong_lang (const char *text, const struct cl_option *option,
 434                      unsigned int lang_mask)
 435 {
 436   char *ok_langs, *bad_lang;
 437
 438   ok_langs = write_langs (option->flags);
 439   bad_lang = write_langs (lang_mask);
 440
 441   /* Eventually this should become a hard error IMO.  */
 442   warning (0, "command line option \"%s\" is valid for %s but not for %s",
 443            text, ok_langs, bad_lang);
 444
 445   free (ok_langs);
 446   free (bad_lang);
 447 }
 448
 449 /* Buffer the unknown option described by the string OPT.  Currently,
 450    we only complain about unknown -Wno-* options if they may have
 451    prevented a diagnostic. Otherwise, we just ignore them.
 452    Note that if we do complain, it is only as a warning, not an error;
 453    passing the compiler an unrecognised -Wno-* option should never
 454    change whether the compilation succeeds or fails.  */
 455
 456 static void postpone_unknown_option_warning(const char *opt)
 457 {
 458   VEC_safe_push (const_char_p, heap, ignored_options, opt);
 459 }
 460
 461 /* Produce a warning for each option previously buffered.  */
 462
 463 void print_ignored_options (void)
 464 {
 465   location_t saved_loc = input_location;
 466
 467   input_location = 0;
 468
 469   while (!VEC_empty (const_char_p, ignored_options))
 470     {
 471       const char *opt;
 472       opt = VEC_pop (const_char_p, ignored_options);
 473       warning (0, "unrecognized command line option \"%s\"", opt);
 474     }
 475
 476   input_location = saved_loc;
 477 }
 478
 479 /* Handle the switch beginning at ARGV for the language indicated by
 480    LANG_MASK.  Returns the number of switches consumed.  */
 481 static unsigned int
 482 handle_option (const char **argv, unsigned int lang_mask)
 483 {
 484   size_t opt_index;
 485   const char *opt, *arg = 0;
 486   char *dup = 0;
 487   int value = 1;
 488   unsigned int result = 0;
 489   const struct cl_option *option;
 490
 491   opt = argv[0];
 492
 493   opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
 494   if (opt_index == cl_options_count
 495       && (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm')
 496       && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
 497     {
 498       /* Drop the "no-" from negative switches.  */
 499       size_t len = strlen (opt) - 3;
 500
 501       dup = XNEWVEC (char, len + 1);
 502       dup[0] = '-';
 503       dup[1] = opt[1];
 504       memcpy (dup + 2, opt + 5, len - 2 + 1);
 505       opt = dup;
 506       value = 0;
 507       opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
 508       if (opt_index == cl_options_count && opt[1] == 'W')
 509         {
 510           /* We don't generate warnings for unknown -Wno-* options
 511              unless we issue diagnostics.  */
 512           postpone_unknown_option_warning (argv[0]);
 513           result = 1;
 514           goto done;
 515         }
 516     }
 517
 518   if (opt_index == cl_options_count)
 519     goto done;
 520
 521   option = &cl_options[opt_index];
 522
 523   /* Reject negative form of switches that don't take negatives as
 524      unrecognized.  */
 525   if (!value && (option->flags & CL_REJECT_NEGATIVE))
 526     goto done;
 527
 528   /* We've recognized this switch.  */
 529   result = 1;
 530
 531   /* Check to see if the option is disabled for this configuration.  */
 532   if (option->flags & CL_DISABLED)
 533     {
 534       error ("command line option %qs"
 535              " is not supported by this configuration", opt);
 536       goto done;
 537     }
 538
 539   /* Sort out any argument the switch takes.  */
 540   if (option->flags & CL_JOINED)
 541     {
 542       /* Have arg point to the original switch.  This is because
 543          some code, such as disable_builtin_function, expects its
 544          argument to be persistent until the program exits.  */
 545       arg = argv[0] + cl_options[opt_index].opt_len + 1;
 546       if (!value)
 547         arg += strlen ("no-");
 548
 549       if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
 550         {
 551           if (option->flags & CL_SEPARATE)
 552             {
 553               arg = argv[1];
 554               result = 2;
 555             }
 556           else
 557             /* Missing argument.  */
 558             arg = NULL;
 559         }
 560     }
 561   else if (option->flags & CL_SEPARATE)
 562     {
 563       arg = argv[1];
 564       result = 2;
 565     }
 566
 567   /* Now we've swallowed any potential argument, complain if this
 568      is a switch for a different front end.  */
 569   if (!(option->flags & (lang_mask | CL_COMMON | CL_TARGET)))
 570     {
 571       complain_wrong_lang (argv[0], option, lang_mask);
 572       goto done;
 573     }
 574   else if ((option->flags & CL_TARGET)
 575            && (option->flags & CL_LANG_ALL)
 576            && !(option->flags & lang_mask))
 577     {
 578       /* Complain for target flag language mismatches if any languages
 579          are specified.  */
 580       complain_wrong_lang (argv[0], option, lang_mask);
 581       goto done;
 582     }
 583
 584   if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
 585     {
 586       if (!lang_hooks.missing_argument (opt, opt_index))
 587         error ("missing argument to \"%s\"", opt);
 588       goto done;
 589     }
 590
 591   /* If the switch takes an integer, convert it.  */
 592   if (arg && (option->flags & CL_UINTEGER))
 593     {
 594       value = integral_argument (arg);
 595       if (value == -1)
 596         {
 597           error ("argument to \"%s\" should be a non-negative integer",
 598                  option->opt_text);
 599           goto done;
 600         }
 601     }
 602
 603   if (option->flag_var)
 604     switch (option->var_type)
 605       {
 606       case CLVC_BOOLEAN:
 607         *(int *) option->flag_var = value;
 608         break;
 609
 610       case CLVC_EQUAL:
 611         *(int *) option->flag_var = (value
 612                                      ? option->var_value
 613                                      : !option->var_value);
 614         break;
 615
 616       case CLVC_BIT_CLEAR:
 617       case CLVC_BIT_SET:
 618         if ((value != 0) == (option->var_type == CLVC_BIT_SET))
 619           *(int *) option->flag_var |= option->var_value;
 620         else
 621           *(int *) option->flag_var &= ~option->var_value;
 622         if (option->flag_var == &target_flags)
 623           target_flags_explicit |= option->var_value;
 624         break;
 625
 626       case CLVC_STRING:
 627         *(const char **) option->flag_var = arg;
 628         break;
 629       }
 630
 631   if (option->flags & lang_mask)
 632     if (lang_hooks.handle_option (opt_index, arg, value) == 0)
 633       result = 0;
 634
 635   if (result && (option->flags & CL_COMMON))
 636     if (common_handle_option (opt_index, arg, value, lang_mask) == 0)
 637       result = 0;
 638
 639   if (result && (option->flags & CL_TARGET))
 640     if (!targetm.handle_option (opt_index, arg, value))
 641       result = 0;
 642
 643  done:
 644   if (dup)
 645     free (dup);
 646   return result;
 647 }
 648
 649 /* Handle FILENAME from the command line.  */
 650 static void
 651 add_input_filename (const char *filename)
 652 {
 653   num_in_fnames++;
 654   in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
 655   in_fnames[num_in_fnames - 1] = filename;
 656 }
 657
 658 /* Add comma-separated strings to a char_p vector.  */
 659
 660 static void
 661 add_comma_separated_to_vector (VEC(char_p,heap) **pvec, const char* arg)
 662 {
 663   char *tmp;
 664   char *r;
 665   char *w;
 666   char *token_start;
 667
 668   /* We never free this string.  */
 669   tmp = xstrdup (arg);
 670
 671   r = tmp;
 672   w = tmp;
 673   token_start = tmp;
 674
 675   while (*r != '\0')
 676     {
 677       if (*r == ',')
 678         {
 679           *w++ = '\0';
 680           ++r;
 681           VEC_safe_push (char_p, heap, *pvec, token_start);
 682           token_start = w;
 683         }
 684       if (*r == '\\' && r[1] == ',')
 685         {
 686           *w++ = ',';
 687           r += 2;
 688         }
 689       else
 690         *w++ = *r++;
 691     }
 692   if (*token_start != '\0')
 693     VEC_safe_push (char_p, heap, *pvec, token_start);
 694 }
 695
 696 /* Return whether we should exclude FNDECL from instrumentation.  */
 697
 698 bool
 699 flag_instrument_functions_exclude_p (tree fndecl)
 700 {
 701   if (VEC_length (char_p, flag_instrument_functions_exclude_functions) > 0)
 702     {
 703       const char *name;
 704       int i;
 705       char *s;
 706
 707       name = lang_hooks.decl_printable_name (fndecl, 0);
 708       for (i = 0;
 709            VEC_iterate (char_p, flag_instrument_functions_exclude_functions,
 710                         i, s);
 711            ++i)
 712         {
 713           if (strstr (name, s) != NULL)
 714             return true;
 715         }
 716     }
 717
 718   if (VEC_length (char_p, flag_instrument_functions_exclude_files) > 0)
 719     {
 720       const char *name;
 721       int i;
 722       char *s;
 723
 724       name = DECL_SOURCE_FILE (fndecl);
 725       for (i = 0;
 726            VEC_iterate (char_p, flag_instrument_functions_exclude_files, i, s);
 727            ++i)
 728         {
 729           if (strstr (name, s) != NULL)
 730             return true;
 731         }
 732     }
 733
 734   return false;
 735 }
 736
 737
 738 /* Decode and handle the vector of command line options.  LANG_MASK
 739    contains has a single bit set representing the current
 740    language.  */
 741 static void
 742 handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
 743 {
 744   unsigned int n, i;
 745
 746   for (i = 1; i < argc; i += n)
 747     {
 748       const char *opt = argv[i];
 749
 750       /* Interpret "-" or a non-switch as a file name.  */
 751       if (opt[0] != '-' || opt[1] == '\0')
 752         {
 753           if (main_input_filename == NULL)
 754             {
 755               main_input_filename = opt;
 756               main_input_baselength
 757                 = base_of_path (main_input_filename, &main_input_basename);
 758             }
 759           add_input_filename (opt);
 760           n = 1;
 761           continue;
 762         }
 763
 764       n = handle_option (argv + i, lang_mask);
 765
 766       if (!n)
 767         {
 768           n = 1;
 769           error ("unrecognized command line option \"%s\"", opt);
 770         }
 771     }
 772 }
 773
 774 /* Parse command line options and set default flag values.  Do minimal
 775    options processing.  */
 776 void
 777 decode_options (unsigned int argc, const char **argv)
 778 {
 779   static bool first_time_p = true;
 780   static int initial_min_crossjump_insns;
 781   static int initial_max_fields_for_field_sensitive;
 782   static int initial_loop_invariant_max_bbs_in_loop;
 783   static unsigned int initial_lang_mask;
 784
 785   unsigned int i, lang_mask;
 786   int opt1;
 787   int opt2;
 788   int opt3;
 789   int opt1_max;
 790
 791   if (first_time_p)
 792     {
 793       /* Perform language-specific options initialization.  */
 794       initial_lang_mask = lang_mask = lang_hooks.init_options (argc, argv);
 795
 796       lang_hooks.initialize_diagnostics (global_dc);
 797
 798       /* Save initial values of parameters we reset.  */
 799       initial_min_crossjump_insns
 800         = compiler_params[PARAM_MIN_CROSSJUMP_INSNS].value;
 801       initial_max_fields_for_field_sensitive
 802         = compiler_params[PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE].value;
 803       initial_loop_invariant_max_bbs_in_loop
 804         = compiler_params[PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP].value;
 805     }
 806   else
 807     lang_mask = initial_lang_mask;
 808
 809   /* Scan to see what optimization level has been specified.  That will
 810      determine the default value of many flags.  */
 811   for (i = 1; i < argc; i++)
 812     {
 813       if (!strcmp (argv[i], "-O"))
 814         {
 815           optimize = 1;
 816           optimize_size = 0;
 817         }
 818       else if (argv[i][0] == '-' && argv[i][1] == 'O')
 819         {
 820           /* Handle -Os, -O2, -O3, -O69, ...  */
 821           const char *p = &argv[i][2];
 822
 823           if ((p[0] == 's') && (p[1] == 0))
 824             {
 825               optimize_size = 1;
 826
 827               /* Optimizing for size forces optimize to be 2.  */
 828               optimize = 2;
 829             }
 830           else
 831             {
 832               const int optimize_val = read_integral_parameter (p, p - 2, -1);
 833               if (optimize_val != -1)
 834                 {
 835                   optimize = optimize_val;
 836                   optimize_size = 0;
 837                 }
 838             }
 839         }
 840     }
 841
 842   /* Use priority coloring if cover classes is not defined for the
 843      target.  */
 844   if (targetm.ira_cover_classes == NULL)
 845     flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
 846
 847   /* -O1 optimizations.  */
 848   opt1 = (optimize >= 1);
 849   flag_defer_pop = opt1;
 850 #ifdef DELAY_SLOTS
 851   flag_delayed_branch = opt1;
 852 #endif
 853 #ifdef CAN_DEBUG_WITHOUT_FP
 854   flag_omit_frame_pointer = opt1;
 855 #endif
 856   flag_guess_branch_prob = opt1;
 857   flag_cprop_registers = opt1;
 858   flag_if_conversion = opt1;
 859   flag_if_conversion2 = opt1;
 860   flag_ipa_pure_const = opt1;
 861   flag_ipa_reference = 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_forward_propagate = opt2;
 884   flag_cse_follow_jumps = opt2;
 885   flag_gcse = opt2;
 886   flag_expensive_optimizations = opt2;
 887   flag_rerun_cse_after_loop = opt2;
 888   flag_caller_saves = opt2;
 889   flag_peephole2 = opt2;
 890 #ifdef INSN_SCHEDULING
 891   flag_schedule_insns = opt2;
 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_delete_null_pointer_checks = 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__version:
1565       print_version (stderr, "");
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_fprofile_arcs:
1771       profile_arc_flag_set = true;
1772       break;
1773
1774     case OPT_finline_functions:
1775       flag_inline_functions_set = true;
1776       break;
1777
1778     case OPT_fprofile_dir_:
1779       profile_data_prefix = xstrdup (arg);
1780       break;
1781
1782     case OPT_fprofile_use_:
1783       profile_data_prefix = xstrdup (arg);
1784       flag_profile_use = true;
1785       value = true;
1786       /* No break here - do -fprofile-use processing. */
1787     case OPT_fprofile_use:
1788       if (!flag_branch_probabilities_set)
1789         flag_branch_probabilities = value;
1790       if (!flag_profile_values_set)
1791         flag_profile_values = value;
1792       if (!flag_unroll_loops_set)
1793         flag_unroll_loops = value;
1794       if (!flag_peel_loops_set)
1795         flag_peel_loops = value;
1796       if (!flag_tracer_set)
1797         flag_tracer = value;
1798       if (!flag_value_profile_transformations_set)
1799         flag_value_profile_transformations = value;
1800       if (!flag_inline_functions_set)
1801         flag_inline_functions = value;
1802       if (!flag_ipa_cp_set)
1803         flag_ipa_cp = value;
1804       if (!flag_ipa_cp_clone_set
1805           && value && flag_ipa_cp)
1806         flag_ipa_cp_clone = value;
1807       if (!flag_predictive_commoning_set)
1808         flag_predictive_commoning = value;
1809       if (!flag_unswitch_loops_set)
1810         flag_unswitch_loops = value;
1811       if (!flag_gcse_after_reload_set)
1812         flag_gcse_after_reload = value;
1813       break;
1814
1815     case OPT_fprofile_generate_:
1816       profile_data_prefix = xstrdup (arg);
1817       value = true;
1818       /* No break here - do -fprofile-generate processing. */
1819     case OPT_fprofile_generate:
1820       if (!profile_arc_flag_set)
1821         profile_arc_flag = value;
1822       if (!flag_profile_values_set)
1823         flag_profile_values = value;
1824       if (!flag_value_profile_transformations_set)
1825         flag_value_profile_transformations = value;
1826       if (!flag_inline_functions_set)
1827         flag_inline_functions = value;
1828       break;
1829
1830     case OPT_fprofile_values:
1831       flag_profile_values_set = true;
1832       break;
1833
1834     case OPT_fvisibility_:
1835       {
1836         if (!strcmp(arg, "default"))
1837           default_visibility = VISIBILITY_DEFAULT;
1838         else if (!strcmp(arg, "internal"))
1839           default_visibility = VISIBILITY_INTERNAL;
1840         else if (!strcmp(arg, "hidden"))
1841           default_visibility = VISIBILITY_HIDDEN;
1842         else if (!strcmp(arg, "protected"))
1843           default_visibility = VISIBILITY_PROTECTED;
1844         else
1845           error ("unrecognized visibility value \"%s\"", arg);
1846       }
1847       break;
1848
1849     case OPT_fvpt:
1850       flag_value_profile_transformations_set = true;
1851       break;
1852
1853     case OPT_frandom_seed:
1854       /* The real switch is -fno-random-seed.  */
1855       if (value)
1856         return 0;
1857       set_random_seed (NULL);
1858       break;
1859
1860     case OPT_frandom_seed_:
1861       set_random_seed (arg);
1862       break;
1863
1864     case OPT_fselective_scheduling:
1865     case OPT_fselective_scheduling2:
1866       sel_sched_switch_set = true;
1867       break;
1868
1869     case OPT_fsched_verbose_:
1870 #ifdef INSN_SCHEDULING
1871       fix_sched_param ("verbose", arg);
1872       break;
1873 #else
1874       return 0;
1875 #endif
1876
1877     case OPT_fsched_stalled_insns_:
1878       flag_sched_stalled_insns = value;
1879       if (flag_sched_stalled_insns == 0)
1880         flag_sched_stalled_insns = -1;
1881       break;
1882
1883     case OPT_fsched_stalled_insns_dep_:
1884       flag_sched_stalled_insns_dep = value;
1885       break;
1886
1887     case OPT_fstack_check_:
1888       if (!strcmp (arg, "no"))
1889         flag_stack_check = NO_STACK_CHECK;
1890       else if (!strcmp (arg, "generic"))
1891         /* This is the old stack checking method.  */
1892         flag_stack_check = STACK_CHECK_BUILTIN
1893                            ? FULL_BUILTIN_STACK_CHECK
1894                            : GENERIC_STACK_CHECK;
1895       else if (!strcmp (arg, "specific"))
1896         /* This is the new stack checking method.  */
1897         flag_stack_check = STACK_CHECK_BUILTIN
1898                            ? FULL_BUILTIN_STACK_CHECK
1899                            : STACK_CHECK_STATIC_BUILTIN
1900                              ? STATIC_BUILTIN_STACK_CHECK
1901                              : GENERIC_STACK_CHECK;
1902       else
1903         warning (0, "unknown stack check parameter \"%s\"", arg);
1904       break;
1905
1906     case OPT_fstack_check:
1907       /* This is the same as the "specific" mode above.  */
1908       if (value)
1909         flag_stack_check = STACK_CHECK_BUILTIN
1910                            ? FULL_BUILTIN_STACK_CHECK
1911                            : STACK_CHECK_STATIC_BUILTIN
1912                              ? STATIC_BUILTIN_STACK_CHECK
1913                              : GENERIC_STACK_CHECK;
1914       else
1915         flag_stack_check = NO_STACK_CHECK;
1916       break;
1917
1918     case OPT_fstack_limit:
1919       /* The real switch is -fno-stack-limit.  */
1920       if (value)
1921         return 0;
1922       stack_limit_rtx = NULL_RTX;
1923       break;
1924
1925     case OPT_fstack_limit_register_:
1926       {
1927         int reg = decode_reg_name (arg);
1928         if (reg < 0)
1929           error ("unrecognized register name \"%s\"", arg);
1930         else
1931           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1932       }
1933       break;
1934
1935     case OPT_fstack_limit_symbol_:
1936       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1937       break;
1938
1939     case OPT_ftree_vectorizer_verbose_:
1940       vect_set_verbosity_level (arg);
1941       break;
1942
1943     case OPT_ftls_model_:
1944       if (!strcmp (arg, "global-dynamic"))
1945         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1946       else if (!strcmp (arg, "local-dynamic"))
1947         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1948       else if (!strcmp (arg, "initial-exec"))
1949         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1950       else if (!strcmp (arg, "local-exec"))
1951         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1952       else
1953         warning (0, "unknown tls-model \"%s\"", arg);
1954       break;
1955
1956     case OPT_fira_algorithm_:
1957       if (!strcmp (arg, "CB"))
1958         flag_ira_algorithm = IRA_ALGORITHM_CB;
1959       else if (!strcmp (arg, "priority"))
1960         flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1961       else
1962         warning (0, "unknown ira algorithm \"%s\"", arg);
1963       break;
1964
1965     case OPT_fira_region_:
1966       if (!strcmp (arg, "one"))
1967         flag_ira_region = IRA_REGION_ONE;
1968       else if (!strcmp (arg, "all"))
1969         flag_ira_region = IRA_REGION_ALL;
1970       else if (!strcmp (arg, "mixed"))
1971         flag_ira_region = IRA_REGION_MIXED;
1972       else
1973         warning (0, "unknown ira region \"%s\"", arg);
1974       break;
1975
1976     case OPT_fira_verbose_:
1977       flag_ira_verbose = value;
1978       break;
1979
1980     case OPT_ftracer:
1981       flag_tracer_set = true;
1982       break;
1983
1984     case OPT_fipa_cp:
1985       flag_ipa_cp_set = true;
1986       break;
1987
1988     case OPT_fipa_cp_clone:
1989       flag_ipa_cp_clone_set = true;
1990       break;
1991
1992     case OPT_fpredictive_commoning:
1993       flag_predictive_commoning_set = true;
1994       break;
1995
1996     case OPT_funswitch_loops:
1997       flag_unswitch_loops_set = true;
1998       break;
1999
2000     case OPT_fgcse_after_reload:
2001       flag_gcse_after_reload_set = true;
2002       break;
2003
2004     case OPT_funroll_loops:
2005       flag_unroll_loops_set = true;
2006       break;
2007
2008     case OPT_g:
2009       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
2010       break;
2011
2012     case OPT_gcoff:
2013       set_debug_level (SDB_DEBUG, false, arg);
2014       break;
2015
2016     case OPT_gdwarf_2:
2017       set_debug_level (DWARF2_DEBUG, false, arg);
2018       break;
2019
2020     case OPT_ggdb:
2021       set_debug_level (NO_DEBUG, 2, arg);
2022       break;
2023
2024     case OPT_gstabs:
2025     case OPT_gstabs_:
2026       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
2027       break;
2028
2029     case OPT_gvms:
2030       set_debug_level (VMS_DEBUG, false, arg);
2031       break;
2032
2033     case OPT_gxcoff:
2034     case OPT_gxcoff_:
2035       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
2036       break;
2037
2038     case OPT_o:
2039       asm_file_name = arg;
2040       break;
2041
2042     case OPT_pedantic_errors:
2043       flag_pedantic_errors = pedantic = 1;
2044       break;
2045
2046     case OPT_floop_optimize:
2047     case OPT_frerun_loop_opt:
2048     case OPT_fstrength_reduce:
2049     case OPT_ftree_store_copy_prop:
2050     case OPT_fforce_addr:
2051     case OPT_ftree_salias:
2052     case OPT_ftree_store_ccp:
2053       /* These are no-ops, preserved for backward compatibility.  */
2054       break;
2055
2056     default:
2057       /* If the flag was handled in a standard way, assume the lack of
2058          processing here is intentional.  */
2059       gcc_assert (cl_options[scode].flag_var);
2060       break;
2061     }
2062
2063   return 1;
2064 }
2065
2066 /* Handle --param NAME=VALUE.  */
2067 static void
2068 handle_param (const char *carg)
2069 {
2070   char *equal, *arg;
2071   int value;
2072
2073   arg = xstrdup (carg);
2074   equal = strchr (arg, '=');
2075   if (!equal)
2076     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
2077   else
2078     {
2079       value = integral_argument (equal + 1);
2080       if (value == -1)
2081         error ("invalid --param value %qs", equal + 1);
2082       else
2083         {
2084           *equal = '\0';
2085           set_param_value (arg, value);
2086         }
2087     }
2088
2089   free (arg);
2090 }
2091
2092 /* Handle -W and -Wextra.  */
2093 static void
2094 set_Wextra (int setting)
2095 {
2096   extra_warnings = setting;
2097
2098   /* We save the value of warn_uninitialized, since if they put
2099      -Wuninitialized on the command line, we need to generate a
2100      warning about not using it without also specifying -O.  */
2101   if (setting == 0)
2102     warn_uninitialized = 0;
2103   else if (warn_uninitialized != 1)
2104     warn_uninitialized = 2;
2105 }
2106
2107 /* Used to set the level of strict aliasing warnings,
2108    when no level is specified (i.e., when -Wstrict-aliasing, and not
2109    -Wstrict-aliasing=level was given).
2110    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2111    and 0 otherwise.  After calling this function, wstrict_aliasing will be
2112    set to the default value of -Wstrict_aliasing=level, currently 3.  */
2113 void
2114 set_Wstrict_aliasing (int onoff)
2115 {
2116   gcc_assert (onoff == 0 || onoff == 1);
2117   if (onoff != 0)
2118     warn_strict_aliasing = 3;
2119   else
2120     warn_strict_aliasing = 0;
2121 }
2122
2123 /* The following routines are useful in setting all the flags that
2124    -ffast-math and -fno-fast-math imply.  */
2125 void
2126 set_fast_math_flags (int set)
2127 {
2128   flag_unsafe_math_optimizations = set;
2129   set_unsafe_math_optimizations_flags (set);
2130   flag_finite_math_only = set;
2131   flag_errno_math = !set;
2132   if (set)
2133     {
2134       flag_signaling_nans = 0;
2135       flag_rounding_math = 0;
2136       flag_cx_limited_range = 1;
2137     }
2138 }
2139
2140 /* When -funsafe-math-optimizations is set the following
2141    flags are set as well.  */
2142 void
2143 set_unsafe_math_optimizations_flags (int set)
2144 {
2145   flag_trapping_math = !set;
2146   flag_signed_zeros = !set;
2147   flag_associative_math = set;
2148   flag_reciprocal_math = set;
2149 }
2150
2151 /* Return true iff flags are set as if -ffast-math.  */
2152 bool
2153 fast_math_flags_set_p (void)
2154 {
2155   return (!flag_trapping_math
2156           && flag_unsafe_math_optimizations
2157           && flag_finite_math_only
2158           && !flag_signed_zeros
2159           && !flag_errno_math);
2160 }
2161
2162 /* Return true iff flags are set as if -ffast-math but using the flags stored
2163    in the struct cl_optimization structure.  */
2164 bool
2165 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2166 {
2167   return (!opt->flag_trapping_math
2168           && opt->flag_unsafe_math_optimizations
2169           && opt->flag_finite_math_only
2170           && !opt->flag_signed_zeros
2171           && !opt->flag_errno_math);
2172 }
2173
2174 /* Handle a debug output -g switch.  EXTENDED is true or false to support
2175    extended output (2 is special and means "-ggdb" was given).  */
2176 static void
2177 set_debug_level (enum debug_info_type type, int extended, const char *arg)
2178 {
2179   static bool type_explicit;
2180
2181   use_gnu_debug_info_extensions = extended;
2182
2183   if (type == NO_DEBUG)
2184     {
2185       if (write_symbols == NO_DEBUG)
2186         {
2187           write_symbols = PREFERRED_DEBUGGING_TYPE;
2188
2189           if (extended == 2)
2190             {
2191 #ifdef DWARF2_DEBUGGING_INFO
2192               write_symbols = DWARF2_DEBUG;
2193 #elif defined DBX_DEBUGGING_INFO
2194               write_symbols = DBX_DEBUG;
2195 #endif
2196             }
2197
2198           if (write_symbols == NO_DEBUG)
2199             warning (0, "target system does not support debug output");
2200         }
2201     }
2202   else
2203     {
2204       /* Does it conflict with an already selected type?  */
2205       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
2206         error ("debug format \"%s\" conflicts with prior selection",
2207                debug_type_names[type]);
2208       write_symbols = type;
2209       type_explicit = true;
2210     }
2211
2212   /* A debug flag without a level defaults to level 2.  */
2213   if (*arg == '\0')
2214     {
2215       if (!debug_info_level)
2216         debug_info_level = 2;
2217     }
2218   else
2219     {
2220       debug_info_level = integral_argument (arg);
2221       if (debug_info_level == (unsigned int) -1)
2222         error ("unrecognised debug output level \"%s\"", arg);
2223       else if (debug_info_level > 3)
2224         error ("debug output level %s is too high", arg);
2225     }
2226 }
2227
2228 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
2229    a simple on-off switch.  */
2230
2231 int
2232 option_enabled (int opt_idx)
2233 {
2234   const struct cl_option *option = &(cl_options[opt_idx]);
2235
2236   if (option->flag_var)
2237     switch (option->var_type)
2238       {
2239       case CLVC_BOOLEAN:
2240         return *(int *) option->flag_var != 0;
2241
2242       case CLVC_EQUAL:
2243         return *(int *) option->flag_var == option->var_value;
2244
2245       case CLVC_BIT_CLEAR:
2246         return (*(int *) option->flag_var & option->var_value) == 0;
2247
2248       case CLVC_BIT_SET:
2249         return (*(int *) option->flag_var & option->var_value) != 0;
2250
2251       case CLVC_STRING:
2252         break;
2253       }
2254   return -1;
2255 }
2256
2257 /* Fill STATE with the current state of option OPTION.  Return true if
2258    there is some state to store.  */
2259
2260 bool
2261 get_option_state (int option, struct cl_option_state *state)
2262 {
2263   if (cl_options[option].flag_var == 0)
2264     return false;
2265
2266   switch (cl_options[option].var_type)
2267     {
2268     case CLVC_BOOLEAN:
2269     case CLVC_EQUAL:
2270       state->data = cl_options[option].flag_var;
2271       state->size = sizeof (int);
2272       break;
2273
2274     case CLVC_BIT_CLEAR:
2275     case CLVC_BIT_SET:
2276       state->ch = option_enabled (option);
2277       state->data = &state->ch;
2278       state->size = 1;
2279       break;
2280
2281     case CLVC_STRING:
2282       state->data = *(const char **) cl_options[option].flag_var;
2283       if (state->data == 0)
2284         state->data = "";
2285       state->size = strlen ((const char *) state->data) + 1;
2286       break;
2287     }
2288   return true;
2289 }
2290
2291 /* Enable a warning option as an error.  This is used by -Werror= and
2292    also by legacy Werror-implicit-function-declaration.  */
2293
2294 void
2295 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask)
2296 {
2297   char *new_option;
2298   int option_index;
2299
2300   new_option = XNEWVEC (char, strlen (arg) + 2);
2301   new_option[0] = 'W';
2302   strcpy (new_option + 1, arg);
2303   option_index = find_opt (new_option, lang_mask);
2304   if (option_index == N_OPTS)
2305     {
2306       error ("-Werror=%s: No option -%s", arg, new_option);
2307     }
2308   else
2309     {
2310       int kind = value ? DK_ERROR : DK_WARNING;
2311       diagnostic_classify_diagnostic (global_dc, option_index, kind);
2312
2313       /* -Werror=foo implies -Wfoo.  */
2314       if (cl_options[option_index].var_type == CLVC_BOOLEAN
2315           && cl_options[option_index].flag_var
2316           && kind == DK_ERROR)
2317         *(int *) cl_options[option_index].flag_var = 1;
2318     }
2319   free (new_option);
2320 }