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