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