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