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