gcc/opts.c

   1 /* Command line option handling.
   2    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   3    Free Software Foundation, Inc.
   4    Contributed by Neil Booth.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "intl.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27 #include "tree.h"
  28 #include "rtl.h"
  29 #include "expr.h"
  30 #include "ggc.h"
  31 #include "output.h"
  32 #include "langhooks.h"
  33 #include "opts.h"
  34 #include "options.h"
  35 #include "flags.h"
  36 #include "toplev.h"
  37 #include "params.h"
  38 #include "diagnostic.h"
  39 #include "tm_p.h"               /* For OPTIMIZATION_OPTIONS.  */
  40 #include "insn-attr.h"          /* For INSN_SCHEDULING.  */
  41 #include "target.h"
  42 #include "tree-pass.h"
  43 #include "dbgcnt.h"
  44 #include "debug.h"
  45
  46 /* Value of the -G xx switch, and whether it was passed or not.  */
  47 unsigned HOST_WIDE_INT g_switch_value;
  48 bool g_switch_set;
  49
  50 /* Same for selective scheduling.  */
  51 bool sel_sched_switch_set;
  52
  53 /* True if we should exit after parsing options.  */
  54 bool exit_after_options;
  55
  56 /* Print various extra warnings.  -W/-Wextra.  */
  57 bool extra_warnings;
  58
  59 /* True to warn about any objects definitions whose size is larger
  60    than N bytes.  Also want about function definitions whose returned
  61    values are larger than N bytes, where N is `larger_than_size'.  */
  62 bool warn_larger_than;
  63 HOST_WIDE_INT larger_than_size;
  64
  65 /* True to warn about any function whose frame size is larger
  66  * than N bytes. */
  67 bool warn_frame_larger_than;
  68 HOST_WIDE_INT frame_larger_than_size;
  69
  70 /* Type(s) of debugging information we are producing (if any).  See
  71    flags.h for the definitions of the different possible types of
  72    debugging information.  */
  73 enum debug_info_type write_symbols = NO_DEBUG;
  74
  75 /* Level of debugging information we are producing.  See flags.h for
  76    the definitions of the different possible levels.  */
  77 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
  78
  79 /* A major contribution to object and executable size is debug
  80    information size.  A major contribution to debug information size
  81    is struct descriptions replicated in several object files. The
  82    following flags attempt to reduce this information.  The basic
  83    idea is to not emit struct debugging information in the current
  84    compilation unit when that information will be generated by
  85    another compilation unit.
  86
  87    Debug information for a struct defined in the current source
  88    file should be generated in the object file.  Likewise the
  89    debug information for a struct defined in a header should be
  90    generated in the object file of the corresponding source file.
  91    Both of these case are handled when the base name of the file of
  92    the struct definition matches the base name of the source file
  93    of the current compilation unit.  This matching emits minimal
  94    struct debugging information.
  95
  96    The base file name matching rule above will fail to emit debug
  97    information for structs defined in system headers.  So a second
  98    category of files includes system headers in addition to files
  99    with matching bases.
 100
 101    The remaining types of files are library headers and application
 102    headers.  We cannot currently distinguish these two types.  */
 103
 104 enum debug_struct_file
 105 {
 106   DINFO_STRUCT_FILE_NONE,   /* Debug no structs. */
 107   DINFO_STRUCT_FILE_BASE,   /* Debug structs defined in files with the
 108                                same base name as the compilation unit. */
 109   DINFO_STRUCT_FILE_SYS,    /* Also debug structs defined in system
 110                                header files.  */
 111   DINFO_STRUCT_FILE_ANY     /* Debug structs defined in all files. */
 112 };
 113
 114 /* Generic structs (e.g. templates not explicitly specialized)
 115    may not have a compilation unit associated with them, and so
 116    may need to be treated differently from ordinary structs.
 117
 118    Structs only handled by reference (indirectly), will also usually
 119    not need as much debugging information.  */
 120
 121 static enum debug_struct_file debug_struct_ordinary[DINFO_USAGE_NUM_ENUMS]
 122   = { DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY };
 123 static enum debug_struct_file debug_struct_generic[DINFO_USAGE_NUM_ENUMS]
 124   = { DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY };
 125
 126 /* Parse the -femit-struct-debug-detailed option value
 127    and set the flag variables. */
 128
 129 #define MATCH( prefix, string ) \
 130   ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
 131    ? ((string += sizeof prefix - 1), 1) : 0)
 132
 133 void
 134 set_struct_debug_option (const char *spec)
 135 {
 136   /* various labels for comparison */
 137   static char dfn_lbl[] = "dfn:", dir_lbl[] = "dir:", ind_lbl[] = "ind:";
 138   static char ord_lbl[] = "ord:", gen_lbl[] = "gen:";
 139   static char none_lbl[] = "none", any_lbl[] = "any";
 140   static char base_lbl[] = "base", sys_lbl[] = "sys";
 141
 142   enum debug_struct_file files = DINFO_STRUCT_FILE_ANY;
 143   /* Default is to apply to as much as possible. */
 144   enum debug_info_usage usage = DINFO_USAGE_NUM_ENUMS;
 145   int ord = 1, gen = 1;
 146
 147   /* What usage? */
 148   if (MATCH (dfn_lbl, spec))
 149     usage = DINFO_USAGE_DFN;
 150   else if (MATCH (dir_lbl, spec))
 151     usage = DINFO_USAGE_DIR_USE;
 152   else if (MATCH (ind_lbl, spec))
 153     usage = DINFO_USAGE_IND_USE;
 154
 155   /* Generics or not? */
 156   if (MATCH (ord_lbl, spec))
 157     gen = 0;
 158   else if (MATCH (gen_lbl, spec))
 159     ord = 0;
 160
 161   /* What allowable environment? */
 162   if (MATCH (none_lbl, spec))
 163     files = DINFO_STRUCT_FILE_NONE;
 164   else if (MATCH (any_lbl, spec))
 165     files = DINFO_STRUCT_FILE_ANY;
 166   else if (MATCH (sys_lbl, spec))
 167     files = DINFO_STRUCT_FILE_SYS;
 168   else if (MATCH (base_lbl, spec))
 169     files = DINFO_STRUCT_FILE_BASE;
 170   else
 171     error ("argument %qs to %<-femit-struct-debug-detailed%> not recognized",
 172            spec);
 173
 174   /* Effect the specification. */
 175   if (usage == DINFO_USAGE_NUM_ENUMS)
 176     {
 177       if (ord)
 178         {
 179           debug_struct_ordinary[DINFO_USAGE_DFN] = files;
 180           debug_struct_ordinary[DINFO_USAGE_DIR_USE] = files;
 181           debug_struct_ordinary[DINFO_USAGE_IND_USE] = files;
 182         }
 183       if (gen)
 184         {
 185           debug_struct_generic[DINFO_USAGE_DFN] = files;
 186           debug_struct_generic[DINFO_USAGE_DIR_USE] = files;
 187           debug_struct_generic[DINFO_USAGE_IND_USE] = files;
 188         }
 189     }
 190   else
 191     {
 192       if (ord)
 193         debug_struct_ordinary[usage] = files;
 194       if (gen)
 195         debug_struct_generic[usage] = files;
 196     }
 197
 198   if (*spec == ',')
 199     set_struct_debug_option (spec+1);
 200   else
 201     {
 202       /* No more -femit-struct-debug-detailed specifications.
 203          Do final checks. */
 204       if (*spec != '\0')
 205         error ("argument %qs to %<-femit-struct-debug-detailed%> unknown",
 206                spec);
 207       if (debug_struct_ordinary[DINFO_USAGE_DIR_USE]
 208                 < debug_struct_ordinary[DINFO_USAGE_IND_USE]
 209           || debug_struct_generic[DINFO_USAGE_DIR_USE]
 210                 < debug_struct_generic[DINFO_USAGE_IND_USE])
 211         error ("%<-femit-struct-debug-detailed=dir:...%> must allow at least"
 212                " as much as %<-femit-struct-debug-detailed=ind:...%>");
 213     }
 214 }
 215
 216 /* Find the base name of a path, stripping off both directories and
 217    a single final extension. */
 218 static int
 219 base_of_path (const char *path, const char **base_out)
 220 {
 221   const char *base = path;
 222   const char *dot = 0;
 223   const char *p = path;
 224   char c = *p;
 225   while (c)
 226     {
 227       if (IS_DIR_SEPARATOR(c))
 228         {
 229           base = p + 1;
 230           dot = 0;
 231         }
 232       else if (c == '.')
 233         dot = p;
 234       c = *++p;
 235     }
 236   if (!dot)
 237     dot = p;
 238   *base_out = base;
 239   return dot - base;
 240 }
 241
 242 /* Match the base name of a file to the base name of a compilation unit. */
 243
 244 static const char *main_input_basename;
 245 static int main_input_baselength;
 246
 247 static int
 248 matches_main_base (const char *path)
 249 {
 250   /* Cache the last query. */
 251   static const char *last_path = NULL;
 252   static int last_match = 0;
 253   if (path != last_path)
 254     {
 255       const char *base;
 256       int length = base_of_path (path, &base);
 257       last_path = path;
 258       last_match = (length == main_input_baselength
 259                     && memcmp (base, main_input_basename, length) == 0);
 260     }
 261   return last_match;
 262 }
 263
 264 #ifdef DEBUG_DEBUG_STRUCT
 265
 266 static int
 267 dump_struct_debug (tree type, enum debug_info_usage usage,
 268                    enum debug_struct_file criterion, int generic,
 269                    int matches, int result)
 270 {
 271   /* Find the type name. */
 272   tree type_decl = TYPE_STUB_DECL (type);
 273   tree t = type_decl;
 274   const char *name = 0;
 275   if (TREE_CODE (t) == TYPE_DECL)
 276     t = DECL_NAME (t);
 277   if (t)
 278     name = IDENTIFIER_POINTER (t);
 279
 280   fprintf (stderr, "    struct %d %s %s %s %s %d %p %s\n",
 281            criterion,
 282            DECL_IN_SYSTEM_HEADER (type_decl) ? "sys" : "usr",
 283            matches ? "bas" : "hdr",
 284            generic ? "gen" : "ord",
 285            usage == DINFO_USAGE_DFN ? ";" :
 286              usage == DINFO_USAGE_DIR_USE ? "." : "*",
 287            result,
 288            (void*) type_decl, name);
 289   return result;
 290 }
 291 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
 292   dump_struct_debug (type, usage, criterion, generic, matches, result)
 293
 294 #else
 295
 296 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
 297   (result)
 298
 299 #endif
 300
 301
 302 bool
 303 should_emit_struct_debug (tree type, enum debug_info_usage usage)
 304 {
 305   enum debug_struct_file criterion;
 306   tree type_decl;
 307   bool generic = lang_hooks.types.generic_p (type);
 308
 309   if (generic)
 310     criterion = debug_struct_generic[usage];
 311   else
 312     criterion = debug_struct_ordinary[usage];
 313
 314   if (criterion == DINFO_STRUCT_FILE_NONE)
 315     return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
 316   if (criterion == DINFO_STRUCT_FILE_ANY)
 317     return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
 318
 319   type_decl = TYPE_STUB_DECL (type);
 320
 321   if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl))
 322     return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
 323
 324   if (matches_main_base (DECL_SOURCE_FILE (type_decl)))
 325     return DUMP_GSTRUCT (type, usage, criterion, generic, true, true);
 326   return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
 327 }
 328
 329 /* Nonzero means use GNU-only extensions in the generated symbolic
 330    debugging information.  Currently, this only has an effect when
 331    write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG.  */
 332 bool use_gnu_debug_info_extensions;
 333
 334 /* The default visibility for all symbols (unless overridden) */
 335 enum symbol_visibility default_visibility = VISIBILITY_DEFAULT;
 336
 337 /* Global visibility options.  */
 338 struct visibility_flags visibility_options;
 339
 340 /* What to print when a switch has no documentation.  */
 341 #ifdef ENABLE_CHECKING
 342 static const char undocumented_msg[] = N_("This switch lacks documentation");
 343 #else
 344 static const char undocumented_msg[] = "";
 345 #endif
 346
 347 /* Used for bookkeeping on whether user set these flags so
 348    -fprofile-use/-fprofile-generate does not use them.  */
 349 static bool profile_arc_flag_set, flag_profile_values_set;
 350 static bool flag_unroll_loops_set, flag_tracer_set;
 351 static bool flag_value_profile_transformations_set;
 352 static bool flag_peel_loops_set, flag_branch_probabilities_set;
 353 static bool flag_inline_functions_set, flag_ipa_cp_set, flag_ipa_cp_clone_set;
 354 static bool flag_predictive_commoning_set, flag_unswitch_loops_set, flag_gcse_after_reload_set;
 355
 356 /* Functions excluded from profiling.  */
 357
 358 typedef char *char_p; /* For DEF_VEC_P.  */
 359 DEF_VEC_P(char_p);
 360 DEF_VEC_ALLOC_P(char_p,heap);
 361
 362 static VEC(char_p,heap) *flag_instrument_functions_exclude_functions;
 363 static VEC(char_p,heap) *flag_instrument_functions_exclude_files;
 364
 365 typedef const char *const_char_p; /* For DEF_VEC_P.  */
 366 DEF_VEC_P(const_char_p);
 367 DEF_VEC_ALLOC_P(const_char_p,heap);
 368
 369 static VEC(const_char_p,heap) *ignored_options;
 370
 371 /* 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 int initial_loop_invariant_max_bbs_in_loop;
 815   static unsigned int initial_lang_mask;
 816
 817   unsigned int i, lang_mask;
 818   int opt1;
 819   int opt2;
 820   int opt3;
 821   int opt1_max;
 822
 823   if (first_time_p)
 824     {
 825       /* Perform language-specific options initialization.  */
 826       initial_lang_mask = lang_mask = lang_hooks.init_options (argc, argv);
 827
 828       lang_hooks.initialize_diagnostics (global_dc);
 829
 830       /* Save initial values of parameters we reset.  */
 831       initial_max_aliased_vops = MAX_ALIASED_VOPS;
 832       initial_avg_aliased_vops = AVG_ALIASED_VOPS;
 833       initial_min_crossjump_insns
 834         = compiler_params[PARAM_MIN_CROSSJUMP_INSNS].value;
 835       initial_max_fields_for_field_sensitive
 836         = compiler_params[PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE].value;
 837       initial_loop_invariant_max_bbs_in_loop
 838         = compiler_params[PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP].value;
 839     }
 840   else
 841     lang_mask = initial_lang_mask;
 842
 843   /* Scan to see what optimization level has been specified.  That will
 844      determine the default value of many flags.  */
 845   for (i = 1; i < argc; i++)
 846     {
 847       if (!strcmp (argv[i], "-O"))
 848         {
 849           optimize = 1;
 850           optimize_size = 0;
 851         }
 852       else if (argv[i][0] == '-' && argv[i][1] == 'O')
 853         {
 854           /* Handle -Os, -O2, -O3, -O69, ...  */
 855           const char *p = &argv[i][2];
 856
 857           if ((p[0] == 's') && (p[1] == 0))
 858             {
 859               optimize_size = 1;
 860
 861               /* Optimizing for size forces optimize to be 2.  */
 862               optimize = 2;
 863             }
 864           else
 865             {
 866               const int optimize_val = read_integral_parameter (p, p - 2, -1);
 867               if (optimize_val != -1)
 868                 {
 869                   optimize = optimize_val;
 870                   optimize_size = 0;
 871                 }
 872             }
 873         }
 874     }
 875
 876   /* Use priority coloring if cover classes is not defined for the
 877      target.  */
 878   if (targetm.ira_cover_classes == NULL)
 879     flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
 880
 881   /* -O1 optimizations.  */
 882   opt1 = (optimize >= 1);
 883   flag_defer_pop = opt1;
 884 #ifdef DELAY_SLOTS
 885   flag_delayed_branch = opt1;
 886 #endif
 887 #ifdef CAN_DEBUG_WITHOUT_FP
 888   flag_omit_frame_pointer = opt1;
 889 #endif
 890   flag_guess_branch_prob = opt1;
 891   flag_cprop_registers = opt1;
 892   flag_if_conversion = opt1;
 893   flag_if_conversion2 = opt1;
 894   flag_ipa_pure_const = opt1;
 895   flag_ipa_reference = opt1;
 896   flag_merge_constants = opt1;
 897   flag_split_wide_types = opt1;
 898   flag_tree_ccp = opt1;
 899   flag_tree_dce = opt1;
 900   flag_tree_dom = opt1;
 901   flag_tree_dse = opt1;
 902   flag_tree_ter = opt1;
 903   flag_tree_sra = opt1;
 904   flag_tree_copyrename = opt1;
 905   flag_tree_fre = opt1;
 906   flag_tree_copy_prop = opt1;
 907   flag_tree_sink = opt1;
 908   flag_tree_ch = opt1;
 909
 910   /* -O2 optimizations.  */
 911   opt2 = (optimize >= 2);
 912   flag_inline_small_functions = opt2;
 913   flag_indirect_inlining = opt2;
 914   flag_thread_jumps = opt2;
 915   flag_crossjumping = opt2;
 916   flag_optimize_sibling_calls = opt2;
 917   flag_forward_propagate = opt2;
 918   flag_cse_follow_jumps = opt2;
 919   flag_gcse = opt2;
 920   flag_expensive_optimizations = opt2;
 921   flag_rerun_cse_after_loop = opt2;
 922   flag_caller_saves = opt2;
 923   flag_peephole2 = opt2;
 924 #ifdef INSN_SCHEDULING
 925   flag_schedule_insns = opt2;
 926   flag_schedule_insns_after_reload = opt2;
 927 #endif
 928   flag_regmove = opt2;
 929   flag_strict_aliasing = opt2;
 930   flag_strict_overflow = opt2;
 931   flag_delete_null_pointer_checks = opt2;
 932   flag_reorder_blocks = opt2;
 933   flag_reorder_functions = opt2;
 934   flag_tree_vrp = opt2;
 935   flag_tree_builtin_call_dce = opt2;
 936   flag_tree_pre = opt2;
 937   flag_tree_switch_conversion = 1;
 938   flag_ipa_cp = opt2;
 939
 940   /* Allow more virtual operators to increase alias precision.  */
 941
 942   set_param_value ("max-aliased-vops",
 943                    (opt2) ? 500 : initial_max_aliased_vops);
 944
 945   /* Track fields in field-sensitive alias analysis.  */
 946   set_param_value ("max-fields-for-field-sensitive",
 947                    (opt2) ? 100 : initial_max_fields_for_field_sensitive);
 948
 949   /* For -O1 only do loop invariant motion for very small loops.  */
 950   set_param_value ("loop-invariant-max-bbs-in-loop",
 951                    (opt2) ? initial_loop_invariant_max_bbs_in_loop : 1000);
 952
 953   /* -O3 optimizations.  */
 954   opt3 = (optimize >= 3);
 955   flag_predictive_commoning = opt3;
 956   flag_inline_functions = opt3;
 957   flag_unswitch_loops = opt3;
 958   flag_gcse_after_reload = opt3;
 959   flag_tree_vectorize = opt3;
 960   flag_ipa_cp_clone = opt3;
 961   if (flag_ipa_cp_clone)
 962     flag_ipa_cp = 1;
 963
 964   /* Allow even more virtual operators.  Max-aliased-vops was set above for
 965      -O2, so don't reset it unless we are at -O3.  */
 966   if (opt3)
 967     set_param_value ("max-aliased-vops", 1000);
 968
 969   set_param_value ("avg-aliased-vops", (opt3) ? 3 : initial_avg_aliased_vops);
 970
 971   /* Just -O1/-O0 optimizations.  */
 972   opt1_max = (optimize <= 1);
 973   align_loops = opt1_max;
 974   align_jumps = opt1_max;
 975   align_labels = opt1_max;
 976   align_functions = opt1_max;
 977
 978   if (optimize_size)
 979     {
 980       /* Inlining of functions reducing size is a good idea regardless of them
 981          being declared inline.  */
 982       flag_inline_functions = 1;
 983
 984       /* Basic optimization options.  */
 985       optimize_size = 1;
 986       if (optimize > 2)
 987         optimize = 2;
 988
 989       /* We want to crossjump as much as possible.  */
 990       set_param_value ("min-crossjump-insns", 1);
 991     }
 992   else
 993     set_param_value ("min-crossjump-insns", initial_min_crossjump_insns);
 994
 995   if (first_time_p)
 996     {
 997       /* Initialize whether `char' is signed.  */
 998       flag_signed_char = DEFAULT_SIGNED_CHAR;
 999       /* Set this to a special "uninitialized" value.  The actual default is
1000          set after target options have been processed.  */
1001       flag_short_enums = 2;
1002
1003       /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
1004          modify it.  */
1005       target_flags = targetm.default_target_flags;
1006
1007       /* Some targets have ABI-specified unwind tables.  */
1008       flag_unwind_tables = targetm.unwind_tables_default;
1009     }
1010
1011 #ifdef OPTIMIZATION_OPTIONS
1012   /* Allow default optimizations to be specified on a per-machine basis.  */
1013   OPTIMIZATION_OPTIONS (optimize, optimize_size);
1014 #endif
1015
1016   handle_options (argc, argv, lang_mask);
1017
1018   /* Handle related options for unit-at-a-time, toplevel-reorder, and
1019      section-anchors.  */
1020   if (!flag_unit_at_a_time)
1021     {
1022       if (flag_section_anchors == 1)
1023         error ("Section anchors must be disabled when unit-at-a-time "
1024                "is disabled.");
1025       flag_section_anchors = 0;
1026       if (flag_toplevel_reorder == 1)
1027         error ("Toplevel reorder must be disabled when unit-at-a-time "
1028                "is disabled.");
1029       flag_toplevel_reorder = 0;
1030     }
1031   /* Unless the user has asked for section anchors, we disable toplevel
1032      reordering at -O0 to disable transformations that might be surprising
1033      to end users and to get -fno-toplevel-reorder tested.  */
1034   if (!optimize && flag_toplevel_reorder == 2 && flag_section_anchors != 1)
1035     {
1036       flag_toplevel_reorder = 0;
1037       flag_section_anchors = 0;
1038     }
1039   if (!flag_toplevel_reorder)
1040     {
1041       if (flag_section_anchors == 1)
1042         error ("section anchors must be disabled when toplevel reorder"
1043                " is disabled");
1044       flag_section_anchors = 0;
1045     }
1046
1047   if (first_time_p)
1048     {
1049       if (flag_pie)
1050         flag_pic = flag_pie;
1051       if (flag_pic && !flag_pie)
1052         flag_shlib = 1;
1053     }
1054
1055   if (optimize == 0)
1056     {
1057       /* Inlining does not work if not optimizing,
1058          so force it not to be done.  */
1059       warn_inline = 0;
1060       flag_no_inline = 1;
1061     }
1062
1063   /* The optimization to partition hot and cold basic blocks into separate
1064      sections of the .o and executable files does not work (currently)
1065      with exception handling.  This is because there is no support for
1066      generating unwind info.  If flag_exceptions is turned on we need to
1067      turn off the partitioning optimization.  */
1068
1069   if (flag_exceptions && flag_reorder_blocks_and_partition)
1070     {
1071       inform (input_location,
1072               "-freorder-blocks-and-partition does not work with exceptions");
1073       flag_reorder_blocks_and_partition = 0;
1074       flag_reorder_blocks = 1;
1075     }
1076
1077   /* If user requested unwind info, then turn off the partitioning
1078      optimization.  */
1079
1080   if (flag_unwind_tables && ! targetm.unwind_tables_default
1081       && flag_reorder_blocks_and_partition)
1082     {
1083       inform (input_location, "-freorder-blocks-and-partition does not support unwind info");
1084       flag_reorder_blocks_and_partition = 0;
1085       flag_reorder_blocks = 1;
1086     }
1087
1088   /* If the target requested unwind info, then turn off the partitioning
1089      optimization with a different message.  Likewise, if the target does not
1090      support named sections.  */
1091
1092   if (flag_reorder_blocks_and_partition
1093       && (!targetm.have_named_sections
1094           || (flag_unwind_tables && targetm.unwind_tables_default)))
1095     {
1096       inform (input_location,
1097               "-freorder-blocks-and-partition does not work on this architecture");
1098       flag_reorder_blocks_and_partition = 0;
1099       flag_reorder_blocks = 1;
1100     }
1101
1102   /* Pipelining of outer loops is only possible when general pipelining
1103      capabilities are requested.  */
1104   if (!flag_sel_sched_pipelining)
1105     flag_sel_sched_pipelining_outer_loops = 0;
1106
1107   if (!targetm.ira_cover_classes
1108       && flag_ira_algorithm == IRA_ALGORITHM_CB)
1109     {
1110       inform (input_location,
1111               "-fira-algorithm=CB does not work on this architecture");
1112       flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1113     }
1114
1115   /* Save the current optimization options if this is the first call.  */
1116   if (first_time_p)
1117     {
1118       optimization_default_node = build_optimization_node ();
1119       optimization_current_node = optimization_default_node;
1120       first_time_p = false;
1121     }
1122   if (flag_conserve_stack)
1123     {
1124       if (!PARAM_SET_P (PARAM_LARGE_STACK_FRAME))
1125         PARAM_VALUE (PARAM_LARGE_STACK_FRAME) = 100;
1126       if (!PARAM_SET_P (PARAM_STACK_FRAME_GROWTH))
1127         PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) = 40;
1128     }
1129
1130 }
1131
1132 #define LEFT_COLUMN     27
1133
1134 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1135    followed by word-wrapped HELP in a second column.  */
1136 static void
1137 wrap_help (const char *help,
1138            const char *item,
1139            unsigned int item_width,
1140            unsigned int columns)
1141 {
1142   unsigned int col_width = LEFT_COLUMN;
1143   unsigned int remaining, room, len;
1144
1145   remaining = strlen (help);
1146
1147   do
1148     {
1149       room = columns - 3 - MAX (col_width, item_width);
1150       if (room > columns)
1151         room = 0;
1152       len = remaining;
1153
1154       if (room < len)
1155         {
1156           unsigned int i;
1157
1158           for (i = 0; help[i]; i++)
1159             {
1160               if (i >= room && len != remaining)
1161                 break;
1162               if (help[i] == ' ')
1163                 len = i;
1164               else if ((help[i] == '-' || help[i] == '/')
1165                        && help[i + 1] != ' '
1166                        && i > 0 && ISALPHA (help[i - 1]))
1167                 len = i + 1;
1168             }
1169         }
1170
1171       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1172       item_width = 0;
1173       while (help[len] == ' ')
1174         len++;
1175       help += len;
1176       remaining -= len;
1177     }
1178   while (remaining);
1179 }
1180
1181 /* Print help for a specific front-end, etc.  */
1182 static void
1183 print_filtered_help (unsigned int include_flags,
1184                      unsigned int exclude_flags,
1185                      unsigned int any_flags,
1186                      unsigned int columns)
1187 {
1188   unsigned int i;
1189   const char *help;
1190   static char *printed = NULL;
1191   bool found = false;
1192   bool displayed = false;
1193
1194   if (include_flags == CL_PARAMS)
1195     {
1196       for (i = 0; i < LAST_PARAM; i++)
1197         {
1198           const char *param = compiler_params[i].option;
1199
1200           help = compiler_params[i].help;
1201           if (help == NULL || *help == '\0')
1202             {
1203               if (exclude_flags & CL_UNDOCUMENTED)
1204                 continue;
1205               help = undocumented_msg;
1206             }
1207
1208           /* Get the translation.  */
1209           help = _(help);
1210
1211           wrap_help (help, param, strlen (param), columns);
1212         }
1213       putchar ('\n');
1214       return;
1215     }
1216
1217   if (!printed)
1218     printed = XCNEWVAR (char, cl_options_count);
1219
1220   for (i = 0; i < cl_options_count; i++)
1221     {
1222       static char new_help[128];
1223       const struct cl_option *option = cl_options + i;
1224       unsigned int len;
1225       const char *opt;
1226       const char *tab;
1227
1228       if (include_flags == 0
1229           || ((option->flags & include_flags) != include_flags))
1230         {
1231           if ((option->flags & any_flags) == 0)
1232             continue;
1233         }
1234
1235       /* Skip unwanted switches.  */
1236       if ((option->flags & exclude_flags) != 0)
1237         continue;
1238
1239       found = true;
1240       /* Skip switches that have already been printed.  */
1241       if (printed[i])
1242         continue;
1243
1244       printed[i] = true;
1245
1246       help = option->help;
1247       if (help == NULL)
1248         {
1249           if (exclude_flags & CL_UNDOCUMENTED)
1250             continue;
1251           help = undocumented_msg;
1252         }
1253
1254       /* Get the translation.  */
1255       help = _(help);
1256
1257       /* Find the gap between the name of the
1258          option and its descriptive text.  */
1259       tab = strchr (help, '\t');
1260       if (tab)
1261         {
1262           len = tab - help;
1263           opt = help;
1264           help = tab + 1;
1265         }
1266       else
1267         {
1268           opt = option->opt_text;
1269           len = strlen (opt);
1270         }
1271
1272       /* With the -Q option enabled we change the descriptive text associated
1273          with an option to be an indication of its current setting.  */
1274       if (!quiet_flag)
1275         {
1276           if (len < (LEFT_COLUMN + 2))
1277             strcpy (new_help, "\t\t");
1278           else
1279             strcpy (new_help, "\t");
1280
1281           if (option->flag_var != NULL)
1282             {
1283               if (option->flags & CL_JOINED)
1284                 {
1285                   if (option->var_type == CLVC_STRING)
1286                     {
1287                       if (* (const char **) option->flag_var != NULL)
1288                         snprintf (new_help + strlen (new_help),
1289                                   sizeof (new_help) - strlen (new_help),
1290                                   * (const char **) option->flag_var);
1291                     }
1292                   else
1293                     sprintf (new_help + strlen (new_help),
1294                              "%#x", * (int *) option->flag_var);
1295                 }
1296               else
1297                 strcat (new_help, option_enabled (i)
1298                         ? _("[enabled]") : _("[disabled]"));
1299             }
1300
1301           help = new_help;
1302         }
1303
1304       wrap_help (help, opt, len, columns);
1305       displayed = true;
1306     }
1307
1308   if (! found)
1309     {
1310       unsigned int langs = include_flags & CL_LANG_ALL;
1311
1312       if (langs == 0)
1313         printf (_(" No options with the desired characteristics were found\n"));
1314       else
1315         {
1316           unsigned int i;
1317
1318           /* PR 31349: Tell the user how to see all of the
1319              options supported by a specific front end.  */
1320           for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1321             if ((1U << i) & langs)
1322               printf (_(" None found.  Use --help=%s to show *all* the options supported by the %s front-end\n"),
1323                       lang_names[i], lang_names[i]);
1324         }
1325
1326     }
1327   else if (! displayed)
1328     printf (_(" All options with the desired characteristics have already been displayed\n"));
1329
1330   putchar ('\n');
1331 }
1332
1333 /* Display help for a specified type of option.
1334    The options must have ALL of the INCLUDE_FLAGS set
1335    ANY of the flags in the ANY_FLAGS set
1336    and NONE of the EXCLUDE_FLAGS set.  */
1337 static void
1338 print_specific_help (unsigned int include_flags,
1339                      unsigned int exclude_flags,
1340                      unsigned int any_flags)
1341 {
1342   unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1343   const char * description = NULL;
1344   const char * descrip_extra = "";
1345   size_t i;
1346   unsigned int flag;
1347   static unsigned int columns = 0;
1348
1349   /* Sanity check: Make sure that we do not have more
1350      languages than we have bits available to enumerate them.  */
1351   gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
1352
1353   /* If we have not done so already, obtain
1354      the desired maximum width of the output.  */
1355   if (columns == 0)
1356     {
1357       const char *p;
1358
1359       GET_ENVIRONMENT (p, "COLUMNS");
1360       if (p != NULL)
1361         {
1362           int value = atoi (p);
1363
1364           if (value > 0)
1365             columns = value;
1366         }
1367
1368       if (columns == 0)
1369         /* Use a reasonable default.  */
1370         columns = 80;
1371     }
1372
1373   /* Decide upon the title for the options that we are going to display.  */
1374   for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1375     {
1376       switch (flag & include_flags)
1377         {
1378         case 0:
1379           break;
1380
1381         case CL_TARGET:
1382           description = _("The following options are target specific");
1383           break;
1384         case CL_WARNING:
1385           description = _("The following options control compiler warning messages");
1386           break;
1387         case CL_OPTIMIZATION:
1388           description = _("The following options control optimizations");
1389           break;
1390         case CL_COMMON:
1391           description = _("The following options are language-independent");
1392           break;
1393         case CL_PARAMS:
1394           description = _("The --param option recognizes the following as parameters");
1395           break;
1396         default:
1397           if (i >= cl_lang_count)
1398             break;
1399           if (exclude_flags & all_langs_mask)
1400             description = _("The following options are specific to just the language ");
1401           else
1402             description = _("The following options are supported by the language ");
1403           descrip_extra = lang_names [i];
1404           break;
1405         }
1406     }
1407
1408   if (description == NULL)
1409     {
1410       if (any_flags == 0)
1411         {
1412           if (include_flags & CL_UNDOCUMENTED)
1413             description = _("The following options are not documented");
1414           else if (include_flags & CL_SEPARATE)
1415             description = _("The following options take separate arguments");
1416           else if (include_flags & CL_JOINED)
1417             description = _("The following options take joined arguments");
1418           else
1419             {
1420               internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1421                               include_flags);
1422               return;
1423             }
1424         }
1425       else
1426         {
1427           if (any_flags & all_langs_mask)
1428             description = _("The following options are language-related");
1429           else
1430             description = _("The following options are language-independent");
1431         }
1432     }
1433
1434   printf ("%s%s:\n", description, descrip_extra);
1435   print_filtered_help (include_flags, exclude_flags, any_flags, columns);
1436 }
1437
1438 /* Handle target- and language-independent options.  Return zero to
1439    generate an "unknown option" message.  Only options that need
1440    extra handling need to be listed here; if you simply want
1441    VALUE assigned to a variable, it happens automatically.  */
1442
1443 static int
1444 common_handle_option (size_t scode, const char *arg, int value,
1445                       unsigned int lang_mask)
1446 {
1447   static bool verbose = false;
1448   enum opt_code code = (enum opt_code) scode;
1449
1450   switch (code)
1451     {
1452     case OPT__param:
1453       handle_param (arg);
1454       break;
1455
1456     case OPT_v:
1457       verbose = true;
1458       break;
1459
1460     case OPT_fhelp:
1461     case OPT__help:
1462       {
1463         unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1464         unsigned int undoc_mask;
1465         unsigned int i;
1466
1467         undoc_mask = (verbose | extra_warnings) ? 0 : CL_UNDOCUMENTED;
1468         /* First display any single language specific options.  */
1469         for (i = 0; i < cl_lang_count; i++)
1470           print_specific_help
1471             (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0);
1472         /* Next display any multi language specific options.  */
1473         print_specific_help (0, undoc_mask, all_langs_mask);
1474         /* Then display any remaining, non-language options.  */
1475         for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1476           print_specific_help (i, undoc_mask, 0);
1477         exit_after_options = true;
1478         break;
1479       }
1480
1481     case OPT_ftarget_help:
1482     case OPT__target_help:
1483       print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0);
1484       exit_after_options = true;
1485
1486       /* Allow the target a chance to give the user some additional information.  */
1487       if (targetm.target_help)
1488         targetm.target_help ();
1489       break;
1490
1491     case OPT_fhelp_:
1492     case OPT__help_:
1493       {
1494         const char * a = arg;
1495         unsigned int include_flags = 0;
1496         /* Note - by default we include undocumented options when listing
1497            specific classes.  If you only want to see documented options
1498            then add ",^undocumented" to the --help= option.  E.g.:
1499
1500            --help=target,^undocumented  */
1501         unsigned int exclude_flags = 0;
1502
1503         /* Walk along the argument string, parsing each word in turn.
1504            The format is:
1505            arg = [^]{word}[,{arg}]
1506            word = {optimizers|target|warnings|undocumented|
1507                    params|common|<language>}  */
1508         while (* a != 0)
1509           {
1510             static struct
1511             {
1512               const char * string;
1513               unsigned int flag;
1514             }
1515             specifics[] =
1516             {
1517               { "optimizers", CL_OPTIMIZATION },
1518               { "target", CL_TARGET },
1519               { "warnings", CL_WARNING },
1520               { "undocumented", CL_UNDOCUMENTED },
1521               { "params", CL_PARAMS },
1522               { "joined", CL_JOINED },
1523               { "separate", CL_SEPARATE },
1524               { "common", CL_COMMON },
1525               { NULL, 0 }
1526             };
1527             unsigned int * pflags;
1528             char * comma;
1529             unsigned int lang_flag, specific_flag;
1530             unsigned int len;
1531             unsigned int i;
1532
1533             if (* a == '^')
1534               {
1535                 ++ a;
1536                 pflags = & exclude_flags;
1537               }
1538             else
1539               pflags = & include_flags;
1540
1541             comma = strchr (a, ',');
1542             if (comma == NULL)
1543               len = strlen (a);
1544             else
1545               len = comma - a;
1546             if (len == 0)
1547               {
1548                 a = comma + 1;
1549                 continue;
1550               }
1551
1552             /* Check to see if the string matches an option class name.  */
1553             for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1554               if (strncasecmp (a, specifics[i].string, len) == 0)
1555                 {
1556                   specific_flag = specifics[i].flag;
1557                   break;
1558                 }
1559
1560             /* Check to see if the string matches a language name.
1561                Note - we rely upon the alpha-sorted nature of the entries in
1562                the lang_names array, specifically that shorter names appear
1563                before their longer variants.  (i.e. C before C++).  That way
1564                when we are attempting to match --help=c for example we will
1565                match with C first and not C++.  */
1566             for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1567               if (strncasecmp (a, lang_names[i], len) == 0)
1568                 {
1569                   lang_flag = 1U << i;
1570                   break;
1571                 }
1572
1573             if (specific_flag != 0)
1574               {
1575                 if (lang_flag == 0)
1576                   * pflags |= specific_flag;
1577                 else
1578                   {
1579                     /* The option's argument matches both the start of a
1580                        language name and the start of an option class name.
1581                        We have a special case for when the user has
1582                        specified "--help=c", but otherwise we have to issue
1583                        a warning.  */
1584                     if (strncasecmp (a, "c", len) == 0)
1585                       * pflags |= lang_flag;
1586                     else
1587                       fnotice (stderr,
1588                                "warning: --help argument %.*s is ambiguous, please be more specific\n",
1589                                len, a);
1590                   }
1591               }
1592             else if (lang_flag != 0)
1593               * pflags |= lang_flag;
1594             else
1595               fnotice (stderr,
1596                        "warning: unrecognized argument to --help= option: %.*s\n",
1597                        len, a);
1598
1599             if (comma == NULL)
1600               break;
1601             a = comma + 1;
1602           }
1603
1604         if (include_flags)
1605           print_specific_help (include_flags, exclude_flags, 0);
1606         exit_after_options = true;
1607         break;
1608       }
1609
1610     case OPT__version:
1611       print_version (stderr, "");
1612       exit_after_options = true;
1613       break;
1614
1615     case OPT_G:
1616       g_switch_value = value;
1617       g_switch_set = true;
1618       break;
1619
1620     case OPT_O:
1621     case OPT_Os:
1622       /* Currently handled in a prescan.  */
1623       break;
1624
1625     case OPT_W:
1626       /* For backward compatibility, -W is the same as -Wextra.  */
1627       set_Wextra (value);
1628       break;
1629
1630     case OPT_Wdisallowed_function_list_:
1631       warn_disallowed_functions = true;
1632       add_comma_separated_to_vector
1633         (&warning_disallowed_functions, arg);
1634       break;
1635
1636     case OPT_Werror_:
1637       enable_warning_as_error (arg, value, lang_mask);
1638       break;
1639
1640     case OPT_Wextra:
1641       set_Wextra (value);
1642       break;
1643
1644     case OPT_Wlarger_than_:
1645       /* This form corresponds to -Wlarger-than-.
1646          Kept for backward compatibility.
1647          Don't use it as the first argument of warning().  */
1648
1649     case OPT_Wlarger_than_eq:
1650       larger_than_size = value;
1651       warn_larger_than = value != -1;
1652       break;
1653
1654     case OPT_Wframe_larger_than_:
1655       frame_larger_than_size = value;
1656       warn_frame_larger_than = value != -1;
1657       break;
1658
1659     case OPT_Wstrict_aliasing:
1660       set_Wstrict_aliasing (value);
1661       break;
1662
1663     case OPT_Wstrict_aliasing_:
1664       warn_strict_aliasing = value;
1665       break;
1666
1667     case OPT_Wstrict_overflow:
1668       warn_strict_overflow = (value
1669                               ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1670                               : 0);
1671       break;
1672
1673     case OPT_Wstrict_overflow_:
1674       warn_strict_overflow = value;
1675       break;
1676
1677     case OPT_Wunused:
1678       warn_unused = value;
1679       break;
1680
1681     case OPT_aux_info:
1682     case OPT_aux_info_:
1683       aux_info_file_name = arg;
1684       flag_gen_aux_info = 1;
1685       break;
1686
1687     case OPT_auxbase:
1688       aux_base_name = arg;
1689       break;
1690
1691     case OPT_auxbase_strip:
1692       {
1693         char *tmp = xstrdup (arg);
1694         strip_off_ending (tmp, strlen (tmp));
1695         if (tmp[0])
1696           aux_base_name = tmp;
1697       }
1698       break;
1699
1700     case OPT_d:
1701       decode_d_option (arg);
1702       break;
1703
1704     case OPT_dumpbase:
1705       dump_base_name = arg;
1706       break;
1707
1708     case OPT_falign_functions_:
1709       align_functions = value;
1710       break;
1711
1712     case OPT_falign_jumps_:
1713       align_jumps = value;
1714       break;
1715
1716     case OPT_falign_labels_:
1717       align_labels = value;
1718       break;
1719
1720     case OPT_falign_loops_:
1721       align_loops = value;
1722       break;
1723
1724     case OPT_fbranch_probabilities:
1725       flag_branch_probabilities_set = true;
1726       break;
1727
1728     case OPT_fcall_used_:
1729       fix_register (arg, 0, 1);
1730       break;
1731
1732     case OPT_fcall_saved_:
1733       fix_register (arg, 0, 0);
1734       break;
1735
1736     case OPT_fdbg_cnt_:
1737       dbg_cnt_process_opt (arg);
1738       break;
1739
1740     case OPT_fdbg_cnt_list:
1741       dbg_cnt_list_all_counters ();
1742       break;
1743
1744     case OPT_fdebug_prefix_map_:
1745       add_debug_prefix_map (arg);
1746       break;
1747
1748     case OPT_fdiagnostics_show_location_:
1749       if (!strcmp (arg, "once"))
1750         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
1751       else if (!strcmp (arg, "every-line"))
1752         diagnostic_prefixing_rule (global_dc)
1753           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
1754       else
1755         return 0;
1756       break;
1757
1758     case OPT_fdiagnostics_show_option:
1759       global_dc->show_option_requested = true;
1760       break;
1761
1762     case OPT_fdump_:
1763       if (!dump_switch_p (arg))
1764         return 0;
1765       break;
1766
1767     case OPT_ffast_math:
1768       set_fast_math_flags (value);
1769       break;
1770
1771     case OPT_funsafe_math_optimizations:
1772       set_unsafe_math_optimizations_flags (value);
1773       break;
1774
1775     case OPT_ffixed_:
1776       fix_register (arg, 1, 1);
1777       break;
1778
1779     case OPT_finline_limit_:
1780     case OPT_finline_limit_eq:
1781       set_param_value ("max-inline-insns-single", value / 2);
1782       set_param_value ("max-inline-insns-auto", value / 2);
1783       break;
1784
1785     case OPT_finstrument_functions_exclude_function_list_:
1786       add_comma_separated_to_vector
1787         (&flag_instrument_functions_exclude_functions, arg);
1788       break;
1789
1790     case OPT_finstrument_functions_exclude_file_list_:
1791       add_comma_separated_to_vector
1792         (&flag_instrument_functions_exclude_files, arg);
1793       break;
1794
1795     case OPT_fmessage_length_:
1796       pp_set_line_maximum_length (global_dc->printer, value);
1797       break;
1798
1799     case OPT_fpack_struct_:
1800       if (value <= 0 || (value & (value - 1)) || value > 16)
1801         error ("structure alignment must be a small power of two, not %d", value);
1802       else
1803         {
1804           initial_max_fld_align = value;
1805           maximum_field_alignment = value * BITS_PER_UNIT;
1806         }
1807       break;
1808
1809     case OPT_fpeel_loops:
1810       flag_peel_loops_set = true;
1811       break;
1812
1813     case OPT_fprofile_arcs:
1814       profile_arc_flag_set = true;
1815       break;
1816
1817     case OPT_finline_functions:
1818       flag_inline_functions_set = true;
1819       break;
1820
1821     case OPT_fprofile_dir_:
1822       profile_data_prefix = xstrdup (arg);
1823       break;
1824
1825     case OPT_fprofile_use_:
1826       profile_data_prefix = xstrdup (arg);
1827       flag_profile_use = true;
1828       value = true;
1829       /* No break here - do -fprofile-use processing. */
1830     case OPT_fprofile_use:
1831       if (!flag_branch_probabilities_set)
1832         flag_branch_probabilities = value;
1833       if (!flag_profile_values_set)
1834         flag_profile_values = value;
1835       if (!flag_unroll_loops_set)
1836         flag_unroll_loops = value;
1837       if (!flag_peel_loops_set)
1838         flag_peel_loops = value;
1839       if (!flag_tracer_set)
1840         flag_tracer = 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       if (!flag_ipa_cp_set)
1846         flag_ipa_cp = value;
1847       if (!flag_ipa_cp_clone_set
1848           && value && flag_ipa_cp)
1849         flag_ipa_cp_clone = value;
1850       if (!flag_predictive_commoning_set)
1851         flag_predictive_commoning = value;
1852       if (!flag_unswitch_loops_set)
1853         flag_unswitch_loops = value;
1854       if (!flag_gcse_after_reload_set)
1855         flag_gcse_after_reload = value;
1856       break;
1857
1858     case OPT_fprofile_generate_:
1859       profile_data_prefix = xstrdup (arg);
1860       value = true;
1861       /* No break here - do -fprofile-generate processing. */
1862     case OPT_fprofile_generate:
1863       if (!profile_arc_flag_set)
1864         profile_arc_flag = value;
1865       if (!flag_profile_values_set)
1866         flag_profile_values = value;
1867       if (!flag_value_profile_transformations_set)
1868         flag_value_profile_transformations = value;
1869       if (!flag_inline_functions_set)
1870         flag_inline_functions = value;
1871       break;
1872
1873     case OPT_fprofile_values:
1874       flag_profile_values_set = true;
1875       break;
1876
1877     case OPT_fvisibility_:
1878       {
1879         if (!strcmp(arg, "default"))
1880           default_visibility = VISIBILITY_DEFAULT;
1881         else if (!strcmp(arg, "internal"))
1882           default_visibility = VISIBILITY_INTERNAL;
1883         else if (!strcmp(arg, "hidden"))
1884           default_visibility = VISIBILITY_HIDDEN;
1885         else if (!strcmp(arg, "protected"))
1886           default_visibility = VISIBILITY_PROTECTED;
1887         else
1888           error ("unrecognized visibility value \"%s\"", arg);
1889       }
1890       break;
1891
1892     case OPT_fvpt:
1893       flag_value_profile_transformations_set = true;
1894       break;
1895
1896     case OPT_frandom_seed:
1897       /* The real switch is -fno-random-seed.  */
1898       if (value)
1899         return 0;
1900       set_random_seed (NULL);
1901       break;
1902
1903     case OPT_frandom_seed_:
1904       set_random_seed (arg);
1905       break;
1906
1907     case OPT_fselective_scheduling:
1908     case OPT_fselective_scheduling2:
1909       sel_sched_switch_set = true;
1910       break;
1911
1912     case OPT_fsched_verbose_:
1913 #ifdef INSN_SCHEDULING
1914       fix_sched_param ("verbose", arg);
1915       break;
1916 #else
1917       return 0;
1918 #endif
1919
1920     case OPT_fsched_stalled_insns_:
1921       flag_sched_stalled_insns = value;
1922       if (flag_sched_stalled_insns == 0)
1923         flag_sched_stalled_insns = -1;
1924       break;
1925
1926     case OPT_fsched_stalled_insns_dep_:
1927       flag_sched_stalled_insns_dep = value;
1928       break;
1929
1930     case OPT_fstack_check_:
1931       if (!strcmp (arg, "no"))
1932         flag_stack_check = NO_STACK_CHECK;
1933       else if (!strcmp (arg, "generic"))
1934         /* This is the old stack checking method.  */
1935         flag_stack_check = STACK_CHECK_BUILTIN
1936                            ? FULL_BUILTIN_STACK_CHECK
1937                            : GENERIC_STACK_CHECK;
1938       else if (!strcmp (arg, "specific"))
1939         /* This is the new stack checking method.  */
1940         flag_stack_check = STACK_CHECK_BUILTIN
1941                            ? FULL_BUILTIN_STACK_CHECK
1942                            : STACK_CHECK_STATIC_BUILTIN
1943                              ? STATIC_BUILTIN_STACK_CHECK
1944                              : GENERIC_STACK_CHECK;
1945       else
1946         warning (0, "unknown stack check parameter \"%s\"", arg);
1947       break;
1948
1949     case OPT_fstack_check:
1950       /* This is the same as the "specific" mode above.  */
1951       if (value)
1952         flag_stack_check = STACK_CHECK_BUILTIN
1953                            ? FULL_BUILTIN_STACK_CHECK
1954                            : STACK_CHECK_STATIC_BUILTIN
1955                              ? STATIC_BUILTIN_STACK_CHECK
1956                              : GENERIC_STACK_CHECK;
1957       else
1958         flag_stack_check = NO_STACK_CHECK;
1959       break;
1960
1961     case OPT_fstack_limit:
1962       /* The real switch is -fno-stack-limit.  */
1963       if (value)
1964         return 0;
1965       stack_limit_rtx = NULL_RTX;
1966       break;
1967
1968     case OPT_fstack_limit_register_:
1969       {
1970         int reg = decode_reg_name (arg);
1971         if (reg < 0)
1972           error ("unrecognized register name \"%s\"", arg);
1973         else
1974           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1975       }
1976       break;
1977
1978     case OPT_fstack_limit_symbol_:
1979       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1980       break;
1981
1982     case OPT_ftree_vectorizer_verbose_:
1983       vect_set_verbosity_level (arg);
1984       break;
1985
1986     case OPT_ftls_model_:
1987       if (!strcmp (arg, "global-dynamic"))
1988         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1989       else if (!strcmp (arg, "local-dynamic"))
1990         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1991       else if (!strcmp (arg, "initial-exec"))
1992         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1993       else if (!strcmp (arg, "local-exec"))
1994         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1995       else
1996         warning (0, "unknown tls-model \"%s\"", arg);
1997       break;
1998
1999     case OPT_fira_algorithm_:
2000       if (!strcmp (arg, "CB"))
2001         flag_ira_algorithm = IRA_ALGORITHM_CB;
2002       else if (!strcmp (arg, "priority"))
2003         flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
2004       else
2005         warning (0, "unknown ira algorithm \"%s\"", arg);
2006       break;
2007
2008     case OPT_fira_region_:
2009       if (!strcmp (arg, "one"))
2010         flag_ira_region = IRA_REGION_ONE;
2011       else if (!strcmp (arg, "all"))
2012         flag_ira_region = IRA_REGION_ALL;
2013       else if (!strcmp (arg, "mixed"))
2014         flag_ira_region = IRA_REGION_MIXED;
2015       else
2016         warning (0, "unknown ira region \"%s\"", arg);
2017       break;
2018
2019     case OPT_fira_verbose_:
2020       flag_ira_verbose = value;
2021       break;
2022
2023     case OPT_ftracer:
2024       flag_tracer_set = true;
2025       break;
2026
2027     case OPT_fipa_cp:
2028       flag_ipa_cp_set = true;
2029       break;
2030
2031     case OPT_fipa_cp_clone:
2032       flag_ipa_cp_clone_set = true;
2033       break;
2034
2035     case OPT_fpredictive_commoning:
2036       flag_predictive_commoning_set = true;
2037       break;
2038
2039     case OPT_funswitch_loops:
2040       flag_unswitch_loops_set = true;
2041       break;
2042
2043     case OPT_fgcse_after_reload:
2044       flag_gcse_after_reload_set = true;
2045       break;
2046
2047     case OPT_funroll_loops:
2048       flag_unroll_loops_set = true;
2049       break;
2050
2051     case OPT_g:
2052       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
2053       break;
2054
2055     case OPT_gcoff:
2056       set_debug_level (SDB_DEBUG, false, arg);
2057       break;
2058
2059     case OPT_gdwarf_2:
2060       set_debug_level (DWARF2_DEBUG, false, arg);
2061       break;
2062
2063     case OPT_ggdb:
2064       set_debug_level (NO_DEBUG, 2, arg);
2065       break;
2066
2067     case OPT_gstabs:
2068     case OPT_gstabs_:
2069       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
2070       break;
2071
2072     case OPT_gvms:
2073       set_debug_level (VMS_DEBUG, false, arg);
2074       break;
2075
2076     case OPT_gxcoff:
2077     case OPT_gxcoff_:
2078       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
2079       break;
2080
2081     case OPT_o:
2082       asm_file_name = arg;
2083       break;
2084
2085     case OPT_pedantic_errors:
2086       flag_pedantic_errors = pedantic = 1;
2087       break;
2088
2089     case OPT_floop_optimize:
2090     case OPT_frerun_loop_opt:
2091     case OPT_fstrength_reduce:
2092     case OPT_ftree_store_copy_prop:
2093     case OPT_fforce_addr:
2094     case OPT_ftree_salias:
2095     case OPT_ftree_store_ccp:
2096       /* These are no-ops, preserved for backward compatibility.  */
2097       break;
2098
2099     default:
2100       /* If the flag was handled in a standard way, assume the lack of
2101          processing here is intentional.  */
2102       gcc_assert (cl_options[scode].flag_var);
2103       break;
2104     }
2105
2106   return 1;
2107 }
2108
2109 /* Handle --param NAME=VALUE.  */
2110 static void
2111 handle_param (const char *carg)
2112 {
2113   char *equal, *arg;
2114   int value;
2115
2116   arg = xstrdup (carg);
2117   equal = strchr (arg, '=');
2118   if (!equal)
2119     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
2120   else
2121     {
2122       value = integral_argument (equal + 1);
2123       if (value == -1)
2124         error ("invalid --param value %qs", equal + 1);
2125       else
2126         {
2127           *equal = '\0';
2128           set_param_value (arg, value);
2129         }
2130     }
2131
2132   free (arg);
2133 }
2134
2135 /* Handle -W and -Wextra.  */
2136 static void
2137 set_Wextra (int setting)
2138 {
2139   extra_warnings = setting;
2140
2141   /* We save the value of warn_uninitialized, since if they put
2142      -Wuninitialized on the command line, we need to generate a
2143      warning about not using it without also specifying -O.  */
2144   if (setting == 0)
2145     warn_uninitialized = 0;
2146   else if (warn_uninitialized != 1)
2147     warn_uninitialized = 2;
2148 }
2149
2150 /* Used to set the level of strict aliasing warnings,
2151    when no level is specified (i.e., when -Wstrict-aliasing, and not
2152    -Wstrict-aliasing=level was given).
2153    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2154    and 0 otherwise.  After calling this function, wstrict_aliasing will be
2155    set to the default value of -Wstrict_aliasing=level, currently 3.  */
2156 void
2157 set_Wstrict_aliasing (int onoff)
2158 {
2159   gcc_assert (onoff == 0 || onoff == 1);
2160   if (onoff != 0)
2161     warn_strict_aliasing = 3;
2162   else
2163     warn_strict_aliasing = 0;
2164 }
2165
2166 /* The following routines are useful in setting all the flags that
2167    -ffast-math and -fno-fast-math imply.  */
2168 void
2169 set_fast_math_flags (int set)
2170 {
2171   flag_unsafe_math_optimizations = set;
2172   set_unsafe_math_optimizations_flags (set);
2173   flag_finite_math_only = set;
2174   flag_errno_math = !set;
2175   if (set)
2176     {
2177       flag_signaling_nans = 0;
2178       flag_rounding_math = 0;
2179       flag_cx_limited_range = 1;
2180     }
2181 }
2182
2183 /* When -funsafe-math-optimizations is set the following
2184    flags are set as well.  */
2185 void
2186 set_unsafe_math_optimizations_flags (int set)
2187 {
2188   flag_trapping_math = !set;
2189   flag_signed_zeros = !set;
2190   flag_associative_math = set;
2191   flag_reciprocal_math = set;
2192 }
2193
2194 /* Return true iff flags are set as if -ffast-math.  */
2195 bool
2196 fast_math_flags_set_p (void)
2197 {
2198   return (!flag_trapping_math
2199           && flag_unsafe_math_optimizations
2200           && flag_finite_math_only
2201           && !flag_signed_zeros
2202           && !flag_errno_math);
2203 }
2204
2205 /* Return true iff flags are set as if -ffast-math but using the flags stored
2206    in the struct cl_optimization structure.  */
2207 bool
2208 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2209 {
2210   return (!opt->flag_trapping_math
2211           && opt->flag_unsafe_math_optimizations
2212           && opt->flag_finite_math_only
2213           && !opt->flag_signed_zeros
2214           && !opt->flag_errno_math);
2215 }
2216
2217 /* Handle a debug output -g switch.  EXTENDED is true or false to support
2218    extended output (2 is special and means "-ggdb" was given).  */
2219 static void
2220 set_debug_level (enum debug_info_type type, int extended, const char *arg)
2221 {
2222   static bool type_explicit;
2223
2224   use_gnu_debug_info_extensions = extended;
2225
2226   if (type == NO_DEBUG)
2227     {
2228       if (write_symbols == NO_DEBUG)
2229         {
2230           write_symbols = PREFERRED_DEBUGGING_TYPE;
2231
2232           if (extended == 2)
2233             {
2234 #ifdef DWARF2_DEBUGGING_INFO
2235               write_symbols = DWARF2_DEBUG;
2236 #elif defined DBX_DEBUGGING_INFO
2237               write_symbols = DBX_DEBUG;
2238 #endif
2239             }
2240
2241           if (write_symbols == NO_DEBUG)
2242             warning (0, "target system does not support debug output");
2243         }
2244     }
2245   else
2246     {
2247       /* Does it conflict with an already selected type?  */
2248       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
2249         error ("debug format \"%s\" conflicts with prior selection",
2250                debug_type_names[type]);
2251       write_symbols = type;
2252       type_explicit = true;
2253     }
2254
2255   /* A debug flag without a level defaults to level 2.  */
2256   if (*arg == '\0')
2257     {
2258       if (!debug_info_level)
2259         debug_info_level = 2;
2260     }
2261   else
2262     {
2263       debug_info_level = integral_argument (arg);
2264       if (debug_info_level == (unsigned int) -1)
2265         error ("unrecognised debug output level \"%s\"", arg);
2266       else if (debug_info_level > 3)
2267         error ("debug output level %s is too high", arg);
2268     }
2269 }
2270
2271 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
2272    a simple on-off switch.  */
2273
2274 int
2275 option_enabled (int opt_idx)
2276 {
2277   const struct cl_option *option = &(cl_options[opt_idx]);
2278
2279   if (option->flag_var)
2280     switch (option->var_type)
2281       {
2282       case CLVC_BOOLEAN:
2283         return *(int *) option->flag_var != 0;
2284
2285       case CLVC_EQUAL:
2286         return *(int *) option->flag_var == option->var_value;
2287
2288       case CLVC_BIT_CLEAR:
2289         return (*(int *) option->flag_var & option->var_value) == 0;
2290
2291       case CLVC_BIT_SET:
2292         return (*(int *) option->flag_var & option->var_value) != 0;
2293
2294       case CLVC_STRING:
2295         break;
2296       }
2297   return -1;
2298 }
2299
2300 /* Fill STATE with the current state of option OPTION.  Return true if
2301    there is some state to store.  */
2302
2303 bool
2304 get_option_state (int option, struct cl_option_state *state)
2305 {
2306   if (cl_options[option].flag_var == 0)
2307     return false;
2308
2309   switch (cl_options[option].var_type)
2310     {
2311     case CLVC_BOOLEAN:
2312     case CLVC_EQUAL:
2313       state->data = cl_options[option].flag_var;
2314       state->size = sizeof (int);
2315       break;
2316
2317     case CLVC_BIT_CLEAR:
2318     case CLVC_BIT_SET:
2319       state->ch = option_enabled (option);
2320       state->data = &state->ch;
2321       state->size = 1;
2322       break;
2323
2324     case CLVC_STRING:
2325       state->data = *(const char **) cl_options[option].flag_var;
2326       if (state->data == 0)
2327         state->data = "";
2328       state->size = strlen ((const char *) state->data) + 1;
2329       break;
2330     }
2331   return true;
2332 }
2333
2334 /* Enable a warning option as an error.  This is used by -Werror= and
2335    also by legacy Werror-implicit-function-declaration.  */
2336
2337 void
2338 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask)
2339 {
2340   char *new_option;
2341   int option_index;
2342
2343   new_option = XNEWVEC (char, strlen (arg) + 2);
2344   new_option[0] = 'W';
2345   strcpy (new_option + 1, arg);
2346   option_index = find_opt (new_option, lang_mask);
2347   if (option_index == N_OPTS)
2348     {
2349       error ("-Werror=%s: No option -%s", arg, new_option);
2350     }
2351   else
2352     {
2353       int kind = value ? DK_ERROR : DK_WARNING;
2354       diagnostic_classify_diagnostic (global_dc, option_index, kind);
2355
2356       /* -Werror=foo implies -Wfoo.  */
2357       if (cl_options[option_index].var_type == CLVC_BOOLEAN
2358           && cl_options[option_index].flag_var
2359           && kind == DK_ERROR)
2360         *(int *) cl_options[option_index].flag_var = 1;
2361     }
2362   free (new_option);
2363 }