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