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