gcc/opts.c

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