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               { "common", CL_COMMON },
1509               { NULL, 0 }
1510             };
1511             unsigned int * pflags;
1512             char * comma;
1513             unsigned int lang_flag, specific_flag;
1514             unsigned int len;
1515             unsigned int i;
1516
1517             if (* a == '^')
1518               {
1519                 ++ a;
1520                 pflags = & exclude_flags;
1521               }
1522             else
1523               pflags = & include_flags;
1524
1525             comma = strchr (a, ',');
1526             if (comma == NULL)
1527               len = strlen (a);
1528             else
1529               len = comma - a;
1530
1531             /* Check to see if the string matches an option class name.  */
1532             for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1533               if (strncasecmp (a, specifics[i].string, len) == 0)
1534                 {
1535                   specific_flag = specifics[i].flag;
1536                   break;
1537                 }
1538
1539             /* Check to see if the string matches a language name.
1540                Note - we rely upon the alpha-sorted nature of the entries in
1541                the lang_names array, specifically that shorter names appear
1542                before their longer variants.  (i.e. C before C++).  That way
1543                when we are attempting to match --help=c for example we will
1544                match with C first and not C++.  */
1545             for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1546               if (strncasecmp (a, lang_names[i], len) == 0)
1547                 {
1548                   lang_flag = 1U << i;
1549                   break;
1550                 }
1551
1552             if (specific_flag != 0)
1553               {
1554                 if (lang_flag == 0)
1555                   * pflags |= specific_flag;
1556                 else
1557                   {
1558                     /* The option's argument matches both the start of a
1559                        language name and the start of an option class name.
1560                        We have a special case for when the user has
1561                        specified "--help=c", but otherwise we have to issue
1562                        a warning.  */
1563                     if (strncasecmp (a, "c", len) == 0)
1564                       * pflags |= lang_flag;
1565                     else
1566                       fnotice (stderr,
1567                                "warning: --help argument %.*s is ambiguous, please be more specific\n",
1568                                len, a);
1569                   }
1570               }
1571             else if (lang_flag != 0)
1572               * pflags |= lang_flag;
1573             else
1574               fnotice (stderr,
1575                        "warning: unrecognized argument to --help= option: %.*s\n",
1576                        len, a);
1577
1578             if (comma == NULL)
1579               break;
1580             a = comma + 1;
1581           }
1582
1583         if (include_flags)
1584           print_specific_help (include_flags, exclude_flags, 0);
1585         exit_after_options = true;
1586         break;
1587       }
1588
1589     case OPT__version:
1590       print_version (stderr, "");
1591       exit_after_options = true;
1592       break;
1593
1594     case OPT_G:
1595       g_switch_value = value;
1596       g_switch_set = true;
1597       break;
1598
1599     case OPT_O:
1600     case OPT_Os:
1601       /* Currently handled in a prescan.  */
1602       break;
1603
1604     case OPT_W:
1605       /* For backward compatibility, -W is the same as -Wextra.  */
1606       set_Wextra (value);
1607       break;
1608
1609     case OPT_Wdisallowed_function_list_:
1610       warn_disallowed_functions = true;
1611       add_comma_separated_to_vector
1612         (&warning_disallowed_functions, arg);
1613       break;
1614
1615     case OPT_Werror_:
1616       enable_warning_as_error (arg, value, lang_mask);
1617       break;
1618
1619     case OPT_Wextra:
1620       set_Wextra (value);
1621       break;
1622
1623     case OPT_Wlarger_than_:
1624       /* This form corresponds to -Wlarger-than-.
1625          Kept for backward compatibility.
1626          Don't use it as the first argument of warning().  */
1627
1628     case OPT_Wlarger_than_eq:
1629       larger_than_size = value;
1630       warn_larger_than = value != -1;
1631       break;
1632
1633     case OPT_Wframe_larger_than_:
1634       frame_larger_than_size = value;
1635       warn_frame_larger_than = value != -1;
1636       break;
1637
1638     case OPT_Wstrict_aliasing:
1639       set_Wstrict_aliasing (value);
1640       break;
1641
1642     case OPT_Wstrict_aliasing_:
1643       warn_strict_aliasing = value;
1644       break;
1645
1646     case OPT_Wstrict_overflow:
1647       warn_strict_overflow = (value
1648                               ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1649                               : 0);
1650       break;
1651
1652     case OPT_Wstrict_overflow_:
1653       warn_strict_overflow = value;
1654       break;
1655
1656     case OPT_Wunused:
1657       warn_unused = value;
1658       break;
1659
1660     case OPT_aux_info:
1661     case OPT_aux_info_:
1662       aux_info_file_name = arg;
1663       flag_gen_aux_info = 1;
1664       break;
1665
1666     case OPT_auxbase:
1667       aux_base_name = arg;
1668       break;
1669
1670     case OPT_auxbase_strip:
1671       {
1672         char *tmp = xstrdup (arg);
1673         strip_off_ending (tmp, strlen (tmp));
1674         if (tmp[0])
1675           aux_base_name = tmp;
1676       }
1677       break;
1678
1679     case OPT_d:
1680       decode_d_option (arg);
1681       break;
1682
1683     case OPT_dumpbase:
1684       dump_base_name = arg;
1685       break;
1686
1687     case OPT_falign_functions_:
1688       align_functions = value;
1689       break;
1690
1691     case OPT_falign_jumps_:
1692       align_jumps = value;
1693       break;
1694
1695     case OPT_falign_labels_:
1696       align_labels = value;
1697       break;
1698
1699     case OPT_falign_loops_:
1700       align_loops = value;
1701       break;
1702
1703     case OPT_fbranch_probabilities:
1704       flag_branch_probabilities_set = true;
1705       break;
1706
1707     case OPT_fcall_used_:
1708       fix_register (arg, 0, 1);
1709       break;
1710
1711     case OPT_fcall_saved_:
1712       fix_register (arg, 0, 0);
1713       break;
1714
1715     case OPT_fdbg_cnt_:
1716       dbg_cnt_process_opt (arg);
1717       break;
1718
1719     case OPT_fdbg_cnt_list:
1720       dbg_cnt_list_all_counters ();
1721       break;
1722
1723     case OPT_fdebug_prefix_map_:
1724       add_debug_prefix_map (arg);
1725       break;
1726
1727     case OPT_fdiagnostics_show_location_:
1728       if (!strcmp (arg, "once"))
1729         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
1730       else if (!strcmp (arg, "every-line"))
1731         diagnostic_prefixing_rule (global_dc)
1732           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
1733       else
1734         return 0;
1735       break;
1736
1737     case OPT_fdiagnostics_show_option:
1738       global_dc->show_option_requested = true;
1739       break;
1740
1741     case OPT_fdump_:
1742       if (!dump_switch_p (arg))
1743         return 0;
1744       break;
1745
1746     case OPT_ffast_math:
1747       set_fast_math_flags (value);
1748       break;
1749
1750     case OPT_funsafe_math_optimizations:
1751       set_unsafe_math_optimizations_flags (value);
1752       break;
1753
1754     case OPT_ffixed_:
1755       fix_register (arg, 1, 1);
1756       break;
1757
1758     case OPT_finline_limit_:
1759     case OPT_finline_limit_eq:
1760       set_param_value ("max-inline-insns-single", value / 2);
1761       set_param_value ("max-inline-insns-auto", value / 2);
1762       break;
1763
1764     case OPT_finstrument_functions_exclude_function_list_:
1765       add_comma_separated_to_vector
1766         (&flag_instrument_functions_exclude_functions, arg);
1767       break;
1768
1769     case OPT_finstrument_functions_exclude_file_list_:
1770       add_comma_separated_to_vector
1771         (&flag_instrument_functions_exclude_files, arg);
1772       break;
1773
1774     case OPT_fmessage_length_:
1775       pp_set_line_maximum_length (global_dc->printer, value);
1776       break;
1777
1778     case OPT_fpack_struct_:
1779       if (value <= 0 || (value & (value - 1)) || value > 16)
1780         error ("structure alignment must be a small power of two, not %d", value);
1781       else
1782         {
1783           initial_max_fld_align = value;
1784           maximum_field_alignment = value * BITS_PER_UNIT;
1785         }
1786       break;
1787
1788     case OPT_fpeel_loops:
1789       flag_peel_loops_set = true;
1790       break;
1791
1792     case OPT_fprofile_arcs:
1793       profile_arc_flag_set = true;
1794       break;
1795
1796     case OPT_finline_functions:
1797       flag_inline_functions_set = true;
1798       break;
1799
1800     case OPT_fprofile_dir_:
1801       profile_data_prefix = xstrdup (arg);
1802       break;
1803
1804     case OPT_fprofile_use_:
1805       profile_data_prefix = xstrdup (arg);
1806       flag_profile_use = true;
1807       value = true;
1808       /* No break here - do -fprofile-use processing. */
1809     case OPT_fprofile_use:
1810       if (!flag_branch_probabilities_set)
1811         flag_branch_probabilities = value;
1812       if (!flag_profile_values_set)
1813         flag_profile_values = value;
1814       if (!flag_unroll_loops_set)
1815         flag_unroll_loops = value;
1816       if (!flag_peel_loops_set)
1817         flag_peel_loops = value;
1818       if (!flag_tracer_set)
1819         flag_tracer = value;
1820       if (!flag_value_profile_transformations_set)
1821         flag_value_profile_transformations = value;
1822       if (!flag_inline_functions_set)
1823         flag_inline_functions = value;
1824       if (!flag_ipa_cp_set)
1825         flag_ipa_cp = value;
1826       if (!flag_ipa_cp_clone_set
1827           && value && flag_ipa_cp)
1828         flag_ipa_cp_clone = value;
1829       if (!flag_predictive_commoning_set)
1830         flag_predictive_commoning = value;
1831       if (!flag_unswitch_loops_set)
1832         flag_unswitch_loops = value;
1833       if (!flag_gcse_after_reload_set)
1834         flag_gcse_after_reload = value;
1835       break;
1836
1837     case OPT_fprofile_generate_:
1838       profile_data_prefix = xstrdup (arg);
1839       value = true;
1840       /* No break here - do -fprofile-generate processing. */
1841     case OPT_fprofile_generate:
1842       if (!profile_arc_flag_set)
1843         profile_arc_flag = value;
1844       if (!flag_profile_values_set)
1845         flag_profile_values = value;
1846       if (!flag_value_profile_transformations_set)
1847         flag_value_profile_transformations = value;
1848       if (!flag_inline_functions_set)
1849         flag_inline_functions = value;
1850       break;
1851
1852     case OPT_fprofile_values:
1853       flag_profile_values_set = true;
1854       break;
1855
1856     case OPT_fvisibility_:
1857       {
1858         if (!strcmp(arg, "default"))
1859           default_visibility = VISIBILITY_DEFAULT;
1860         else if (!strcmp(arg, "internal"))
1861           default_visibility = VISIBILITY_INTERNAL;
1862         else if (!strcmp(arg, "hidden"))
1863           default_visibility = VISIBILITY_HIDDEN;
1864         else if (!strcmp(arg, "protected"))
1865           default_visibility = VISIBILITY_PROTECTED;
1866         else
1867           error ("unrecognized visibility value \"%s\"", arg);
1868       }
1869       break;
1870
1871     case OPT_fvpt:
1872       flag_value_profile_transformations_set = true;
1873       break;
1874
1875     case OPT_frandom_seed:
1876       /* The real switch is -fno-random-seed.  */
1877       if (value)
1878         return 0;
1879       set_random_seed (NULL);
1880       break;
1881
1882     case OPT_frandom_seed_:
1883       set_random_seed (arg);
1884       break;
1885
1886     case OPT_fselective_scheduling:
1887     case OPT_fselective_scheduling2:
1888       sel_sched_switch_set = true;
1889       break;
1890
1891     case OPT_fsched_verbose_:
1892 #ifdef INSN_SCHEDULING
1893       fix_sched_param ("verbose", arg);
1894       break;
1895 #else
1896       return 0;
1897 #endif
1898
1899     case OPT_fsched_stalled_insns_:
1900       flag_sched_stalled_insns = value;
1901       if (flag_sched_stalled_insns == 0)
1902         flag_sched_stalled_insns = -1;
1903       break;
1904
1905     case OPT_fsched_stalled_insns_dep_:
1906       flag_sched_stalled_insns_dep = value;
1907       break;
1908
1909     case OPT_fstack_check_:
1910       if (!strcmp (arg, "no"))
1911         flag_stack_check = NO_STACK_CHECK;
1912       else if (!strcmp (arg, "generic"))
1913         /* This is the old stack checking method.  */
1914         flag_stack_check = STACK_CHECK_BUILTIN
1915                            ? FULL_BUILTIN_STACK_CHECK
1916                            : GENERIC_STACK_CHECK;
1917       else if (!strcmp (arg, "specific"))
1918         /* This is the new stack checking method.  */
1919         flag_stack_check = STACK_CHECK_BUILTIN
1920                            ? FULL_BUILTIN_STACK_CHECK
1921                            : STACK_CHECK_STATIC_BUILTIN
1922                              ? STATIC_BUILTIN_STACK_CHECK
1923                              : GENERIC_STACK_CHECK;
1924       else
1925         warning (0, "unknown stack check parameter \"%s\"", arg);
1926       break;
1927
1928     case OPT_fstack_check:
1929       /* This is the same as the "specific" mode above.  */
1930       if (value)
1931         flag_stack_check = STACK_CHECK_BUILTIN
1932                            ? FULL_BUILTIN_STACK_CHECK
1933                            : STACK_CHECK_STATIC_BUILTIN
1934                              ? STATIC_BUILTIN_STACK_CHECK
1935                              : GENERIC_STACK_CHECK;
1936       else
1937         flag_stack_check = NO_STACK_CHECK;
1938       break;
1939
1940     case OPT_fstack_limit:
1941       /* The real switch is -fno-stack-limit.  */
1942       if (value)
1943         return 0;
1944       stack_limit_rtx = NULL_RTX;
1945       break;
1946
1947     case OPT_fstack_limit_register_:
1948       {
1949         int reg = decode_reg_name (arg);
1950         if (reg < 0)
1951           error ("unrecognized register name \"%s\"", arg);
1952         else
1953           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1954       }
1955       break;
1956
1957     case OPT_fstack_limit_symbol_:
1958       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1959       break;
1960
1961     case OPT_ftree_vectorizer_verbose_:
1962       vect_set_verbosity_level (arg);
1963       break;
1964
1965     case OPT_ftls_model_:
1966       if (!strcmp (arg, "global-dynamic"))
1967         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1968       else if (!strcmp (arg, "local-dynamic"))
1969         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1970       else if (!strcmp (arg, "initial-exec"))
1971         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1972       else if (!strcmp (arg, "local-exec"))
1973         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1974       else
1975         warning (0, "unknown tls-model \"%s\"", arg);
1976       break;
1977
1978     case OPT_fira_algorithm_:
1979       if (!strcmp (arg, "regional"))
1980         flag_ira_algorithm = IRA_ALGORITHM_REGIONAL;
1981       else if (!strcmp (arg, "CB"))
1982         flag_ira_algorithm = IRA_ALGORITHM_CB;
1983       else if (!strcmp (arg, "mixed"))
1984         flag_ira_algorithm = IRA_ALGORITHM_MIXED;
1985       else
1986         warning (0, "unknown ira algorithm \"%s\"", arg);
1987       break;
1988
1989     case OPT_fira_verbose_:
1990       flag_ira_verbose = value;
1991       break;
1992
1993     case OPT_ftracer:
1994       flag_tracer_set = true;
1995       break;
1996
1997     case OPT_fipa_cp:
1998       flag_ipa_cp_set = true;
1999       break;
2000
2001     case OPT_fipa_cp_clone:
2002       flag_ipa_cp_clone_set = true;
2003       break;
2004
2005     case OPT_fpredictive_commoning:
2006       flag_predictive_commoning_set = true;
2007       break;
2008
2009     case OPT_funswitch_loops:
2010       flag_unswitch_loops_set = true;
2011       break;
2012
2013     case OPT_fgcse_after_reload:
2014       flag_gcse_after_reload_set = true;
2015       break;
2016
2017     case OPT_funroll_loops:
2018       flag_unroll_loops_set = true;
2019       break;
2020
2021     case OPT_g:
2022       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
2023       break;
2024
2025     case OPT_gcoff:
2026       set_debug_level (SDB_DEBUG, false, arg);
2027       break;
2028
2029     case OPT_gdwarf_2:
2030       set_debug_level (DWARF2_DEBUG, false, arg);
2031       break;
2032
2033     case OPT_ggdb:
2034       set_debug_level (NO_DEBUG, 2, arg);
2035       break;
2036
2037     case OPT_gstabs:
2038     case OPT_gstabs_:
2039       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
2040       break;
2041
2042     case OPT_gvms:
2043       set_debug_level (VMS_DEBUG, false, arg);
2044       break;
2045
2046     case OPT_gxcoff:
2047     case OPT_gxcoff_:
2048       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
2049       break;
2050
2051     case OPT_o:
2052       asm_file_name = arg;
2053       break;
2054
2055     case OPT_pedantic_errors:
2056       flag_pedantic_errors = pedantic = 1;
2057       break;
2058
2059     case OPT_floop_optimize:
2060     case OPT_frerun_loop_opt:
2061     case OPT_fstrength_reduce:
2062     case OPT_ftree_store_copy_prop:
2063     case OPT_fforce_addr:
2064     case OPT_ftree_salias:
2065     case OPT_ftree_store_ccp:
2066       /* These are no-ops, preserved for backward compatibility.  */
2067       break;
2068
2069     default:
2070       /* If the flag was handled in a standard way, assume the lack of
2071          processing here is intentional.  */
2072       gcc_assert (cl_options[scode].flag_var);
2073       break;
2074     }
2075
2076   return 1;
2077 }
2078
2079 /* Handle --param NAME=VALUE.  */
2080 static void
2081 handle_param (const char *carg)
2082 {
2083   char *equal, *arg;
2084   int value;
2085
2086   arg = xstrdup (carg);
2087   equal = strchr (arg, '=');
2088   if (!equal)
2089     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
2090   else
2091     {
2092       value = integral_argument (equal + 1);
2093       if (value == -1)
2094         error ("invalid --param value %qs", equal + 1);
2095       else
2096         {
2097           *equal = '\0';
2098           set_param_value (arg, value);
2099         }
2100     }
2101
2102   free (arg);
2103 }
2104
2105 /* Handle -W and -Wextra.  */
2106 static void
2107 set_Wextra (int setting)
2108 {
2109   extra_warnings = setting;
2110
2111   /* We save the value of warn_uninitialized, since if they put
2112      -Wuninitialized on the command line, we need to generate a
2113      warning about not using it without also specifying -O.  */
2114   if (setting == 0)
2115     warn_uninitialized = 0;
2116   else if (warn_uninitialized != 1)
2117     warn_uninitialized = 2;
2118 }
2119
2120 /* Used to set the level of strict aliasing warnings,
2121    when no level is specified (i.e., when -Wstrict-aliasing, and not
2122    -Wstrict-aliasing=level was given).
2123    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2124    and 0 otherwise.  After calling this function, wstrict_aliasing will be
2125    set to the default value of -Wstrict_aliasing=level, currently 3.  */
2126 void
2127 set_Wstrict_aliasing (int onoff)
2128 {
2129   gcc_assert (onoff == 0 || onoff == 1);
2130   if (onoff != 0)
2131     warn_strict_aliasing = 3;
2132   else
2133     warn_strict_aliasing = 0;
2134 }
2135
2136 /* The following routines are useful in setting all the flags that
2137    -ffast-math and -fno-fast-math imply.  */
2138 void
2139 set_fast_math_flags (int set)
2140 {
2141   flag_unsafe_math_optimizations = set;
2142   set_unsafe_math_optimizations_flags (set);
2143   flag_finite_math_only = set;
2144   flag_errno_math = !set;
2145   if (set)
2146     {
2147       flag_signaling_nans = 0;
2148       flag_rounding_math = 0;
2149       flag_cx_limited_range = 1;
2150     }
2151 }
2152
2153 /* When -funsafe-math-optimizations is set the following
2154    flags are set as well.  */
2155 void
2156 set_unsafe_math_optimizations_flags (int set)
2157 {
2158   flag_trapping_math = !set;
2159   flag_signed_zeros = !set;
2160   flag_associative_math = set;
2161   flag_reciprocal_math = set;
2162 }
2163
2164 /* Return true iff flags are set as if -ffast-math.  */
2165 bool
2166 fast_math_flags_set_p (void)
2167 {
2168   return (!flag_trapping_math
2169           && flag_unsafe_math_optimizations
2170           && flag_finite_math_only
2171           && !flag_signed_zeros
2172           && !flag_errno_math);
2173 }
2174
2175 /* Return true iff flags are set as if -ffast-math but using the flags stored
2176    in the struct cl_optimization structure.  */
2177 bool
2178 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2179 {
2180   return (!opt->flag_trapping_math
2181           && opt->flag_unsafe_math_optimizations
2182           && opt->flag_finite_math_only
2183           && !opt->flag_signed_zeros
2184           && !opt->flag_errno_math);
2185 }
2186
2187 /* Handle a debug output -g switch.  EXTENDED is true or false to support
2188    extended output (2 is special and means "-ggdb" was given).  */
2189 static void
2190 set_debug_level (enum debug_info_type type, int extended, const char *arg)
2191 {
2192   static bool type_explicit;
2193
2194   use_gnu_debug_info_extensions = extended;
2195
2196   if (type == NO_DEBUG)
2197     {
2198       if (write_symbols == NO_DEBUG)
2199         {
2200           write_symbols = PREFERRED_DEBUGGING_TYPE;
2201
2202           if (extended == 2)
2203             {
2204 #ifdef DWARF2_DEBUGGING_INFO
2205               write_symbols = DWARF2_DEBUG;
2206 #elif defined DBX_DEBUGGING_INFO
2207               write_symbols = DBX_DEBUG;
2208 #endif
2209             }
2210
2211           if (write_symbols == NO_DEBUG)
2212             warning (0, "target system does not support debug output");
2213         }
2214     }
2215   else
2216     {
2217       /* Does it conflict with an already selected type?  */
2218       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
2219         error ("debug format \"%s\" conflicts with prior selection",
2220                debug_type_names[type]);
2221       write_symbols = type;
2222       type_explicit = true;
2223     }
2224
2225   /* A debug flag without a level defaults to level 2.  */
2226   if (*arg == '\0')
2227     {
2228       if (!debug_info_level)
2229         debug_info_level = 2;
2230     }
2231   else
2232     {
2233       debug_info_level = integral_argument (arg);
2234       if (debug_info_level == (unsigned int) -1)
2235         error ("unrecognised debug output level \"%s\"", arg);
2236       else if (debug_info_level > 3)
2237         error ("debug output level %s is too high", arg);
2238     }
2239 }
2240
2241 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
2242    a simple on-off switch.  */
2243
2244 int
2245 option_enabled (int opt_idx)
2246 {
2247   const struct cl_option *option = &(cl_options[opt_idx]);
2248
2249   if (option->flag_var)
2250     switch (option->var_type)
2251       {
2252       case CLVC_BOOLEAN:
2253         return *(int *) option->flag_var != 0;
2254
2255       case CLVC_EQUAL:
2256         return *(int *) option->flag_var == option->var_value;
2257
2258       case CLVC_BIT_CLEAR:
2259         return (*(int *) option->flag_var & option->var_value) == 0;
2260
2261       case CLVC_BIT_SET:
2262         return (*(int *) option->flag_var & option->var_value) != 0;
2263
2264       case CLVC_STRING:
2265         break;
2266       }
2267   return -1;
2268 }
2269
2270 /* Fill STATE with the current state of option OPTION.  Return true if
2271    there is some state to store.  */
2272
2273 bool
2274 get_option_state (int option, struct cl_option_state *state)
2275 {
2276   if (cl_options[option].flag_var == 0)
2277     return false;
2278
2279   switch (cl_options[option].var_type)
2280     {
2281     case CLVC_BOOLEAN:
2282     case CLVC_EQUAL:
2283       state->data = cl_options[option].flag_var;
2284       state->size = sizeof (int);
2285       break;
2286
2287     case CLVC_BIT_CLEAR:
2288     case CLVC_BIT_SET:
2289       state->ch = option_enabled (option);
2290       state->data = &state->ch;
2291       state->size = 1;
2292       break;
2293
2294     case CLVC_STRING:
2295       state->data = *(const char **) cl_options[option].flag_var;
2296       if (state->data == 0)
2297         state->data = "";
2298       state->size = strlen ((const char *) state->data) + 1;
2299       break;
2300     }
2301   return true;
2302 }
2303
2304 /* Enable a warning option as an error.  This is used by -Werror= and
2305    also by legacy Werror-implicit-function-declaration.  */
2306
2307 void
2308 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask)
2309 {
2310   char *new_option;
2311   int option_index;
2312
2313   new_option = XNEWVEC (char, strlen (arg) + 2);
2314   new_option[0] = 'W';
2315   strcpy (new_option + 1, arg);
2316   option_index = find_opt (new_option, lang_mask);
2317   if (option_index == N_OPTS)
2318     {
2319       error ("-Werror=%s: No option -%s", arg, new_option);
2320     }
2321   else
2322     {
2323       int kind = value ? DK_ERROR : DK_WARNING;
2324       diagnostic_classify_diagnostic (global_dc, option_index, kind);
2325
2326       /* -Werror=foo implies -Wfoo.  */
2327       if (cl_options[option_index].var_type == CLVC_BOOLEAN
2328           && cl_options[option_index].flag_var
2329           && kind == DK_ERROR)
2330         *(int *) cl_options[option_index].flag_var = 1;
2331     }
2332   free (new_option);
2333 }