gcc/opts.c

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