gcc/opts.c

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