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_pta = 0;
1154       flag_ipa_struct_reorg = 0;
1155     }
1156
1157   if (flag_lto || flag_whopr)
1158     {
1159 #ifdef ENABLE_LTO
1160       flag_generate_lto = 1;
1161
1162       /* When generating IL, do not operate in whole-program mode.
1163          Otherwise, symbols will be privatized too early, causing link
1164          errors later.  */
1165       flag_whole_program = 0;
1166 #else
1167       error ("LTO support has not been enabled in this configuration");
1168 #endif
1169     }
1170
1171   /* Reconcile -flto and -fwhopr.  Set additional flags as appropriate and
1172      check option consistency.  */
1173   if (flag_lto && flag_whopr)
1174     error ("-flto and -fwhopr are mutually exclusive");
1175 }
1176
1177 #define LEFT_COLUMN     27
1178
1179 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1180    followed by word-wrapped HELP in a second column.  */
1181 static void
1182 wrap_help (const char *help,
1183            const char *item,
1184            unsigned int item_width,
1185            unsigned int columns)
1186 {
1187   unsigned int col_width = LEFT_COLUMN;
1188   unsigned int remaining, room, len;
1189
1190   remaining = strlen (help);
1191
1192   do
1193     {
1194       room = columns - 3 - MAX (col_width, item_width);
1195       if (room > columns)
1196         room = 0;
1197       len = remaining;
1198
1199       if (room < len)
1200         {
1201           unsigned int i;
1202
1203           for (i = 0; help[i]; i++)
1204             {
1205               if (i >= room && len != remaining)
1206                 break;
1207               if (help[i] == ' ')
1208                 len = i;
1209               else if ((help[i] == '-' || help[i] == '/')
1210                        && help[i + 1] != ' '
1211                        && i > 0 && ISALPHA (help[i - 1]))
1212                 len = i + 1;
1213             }
1214         }
1215
1216       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1217       item_width = 0;
1218       while (help[len] == ' ')
1219         len++;
1220       help += len;
1221       remaining -= len;
1222     }
1223   while (remaining);
1224 }
1225
1226 /* Print help for a specific front-end, etc.  */
1227 static void
1228 print_filtered_help (unsigned int include_flags,
1229                      unsigned int exclude_flags,
1230                      unsigned int any_flags,
1231                      unsigned int columns)
1232 {
1233   unsigned int i;
1234   const char *help;
1235   static char *printed = NULL;
1236   bool found = false;
1237   bool displayed = false;
1238
1239   if (include_flags == CL_PARAMS)
1240     {
1241       for (i = 0; i < LAST_PARAM; i++)
1242         {
1243           const char *param = compiler_params[i].option;
1244
1245           help = compiler_params[i].help;
1246           if (help == NULL || *help == '\0')
1247             {
1248               if (exclude_flags & CL_UNDOCUMENTED)
1249                 continue;
1250               help = undocumented_msg;
1251             }
1252
1253           /* Get the translation.  */
1254           help = _(help);
1255
1256           wrap_help (help, param, strlen (param), columns);
1257         }
1258       putchar ('\n');
1259       return;
1260     }
1261
1262   if (!printed)
1263     printed = XCNEWVAR (char, cl_options_count);
1264
1265   for (i = 0; i < cl_options_count; i++)
1266     {
1267       static char new_help[128];
1268       const struct cl_option *option = cl_options + i;
1269       unsigned int len;
1270       const char *opt;
1271       const char *tab;
1272
1273       if (include_flags == 0
1274           || ((option->flags & include_flags) != include_flags))
1275         {
1276           if ((option->flags & any_flags) == 0)
1277             continue;
1278         }
1279
1280       /* Skip unwanted switches.  */
1281       if ((option->flags & exclude_flags) != 0)
1282         continue;
1283
1284       found = true;
1285       /* Skip switches that have already been printed.  */
1286       if (printed[i])
1287         continue;
1288
1289       printed[i] = true;
1290
1291       help = option->help;
1292       if (help == NULL)
1293         {
1294           if (exclude_flags & CL_UNDOCUMENTED)
1295             continue;
1296           help = undocumented_msg;
1297         }
1298
1299       /* Get the translation.  */
1300       help = _(help);
1301
1302       /* Find the gap between the name of the
1303          option and its descriptive text.  */
1304       tab = strchr (help, '\t');
1305       if (tab)
1306         {
1307           len = tab - help;
1308           opt = help;
1309           help = tab + 1;
1310         }
1311       else
1312         {
1313           opt = option->opt_text;
1314           len = strlen (opt);
1315         }
1316
1317       /* With the -Q option enabled we change the descriptive text associated
1318          with an option to be an indication of its current setting.  */
1319       if (!quiet_flag)
1320         {
1321           if (len < (LEFT_COLUMN + 2))
1322             strcpy (new_help, "\t\t");
1323           else
1324             strcpy (new_help, "\t");
1325
1326           if (option->flag_var != NULL)
1327             {
1328               if (option->flags & CL_JOINED)
1329                 {
1330                   if (option->var_type == CLVC_STRING)
1331                     {
1332                       if (* (const char **) option->flag_var != NULL)
1333                         snprintf (new_help + strlen (new_help),
1334                                   sizeof (new_help) - strlen (new_help),
1335                                   * (const char **) option->flag_var);
1336                     }
1337                   else
1338                     sprintf (new_help + strlen (new_help),
1339                              "%#x", * (int *) option->flag_var);
1340                 }
1341               else
1342                 strcat (new_help, option_enabled (i)
1343                         ? _("[enabled]") : _("[disabled]"));
1344             }
1345
1346           help = new_help;
1347         }
1348
1349       wrap_help (help, opt, len, columns);
1350       displayed = true;
1351     }
1352
1353   if (! found)
1354     {
1355       unsigned int langs = include_flags & CL_LANG_ALL;
1356
1357       if (langs == 0)
1358         printf (_(" No options with the desired characteristics were found\n"));
1359       else
1360         {
1361           unsigned int i;
1362
1363           /* PR 31349: Tell the user how to see all of the
1364              options supported by a specific front end.  */
1365           for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1366             if ((1U << i) & langs)
1367               printf (_(" None found.  Use --help=%s to show *all* the options supported by the %s front-end\n"),
1368                       lang_names[i], lang_names[i]);
1369         }
1370
1371     }
1372   else if (! displayed)
1373     printf (_(" All options with the desired characteristics have already been displayed\n"));
1374
1375   putchar ('\n');
1376 }
1377
1378 /* Display help for a specified type of option.
1379    The options must have ALL of the INCLUDE_FLAGS set
1380    ANY of the flags in the ANY_FLAGS set
1381    and NONE of the EXCLUDE_FLAGS set.  */
1382 static void
1383 print_specific_help (unsigned int include_flags,
1384                      unsigned int exclude_flags,
1385                      unsigned int any_flags)
1386 {
1387   unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1388   const char * description = NULL;
1389   const char * descrip_extra = "";
1390   size_t i;
1391   unsigned int flag;
1392   static unsigned int columns = 0;
1393
1394   /* Sanity check: Make sure that we do not have more
1395      languages than we have bits available to enumerate them.  */
1396   gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
1397
1398   /* If we have not done so already, obtain
1399      the desired maximum width of the output.  */
1400   if (columns == 0)
1401     {
1402       const char *p;
1403
1404       GET_ENVIRONMENT (p, "COLUMNS");
1405       if (p != NULL)
1406         {
1407           int value = atoi (p);
1408
1409           if (value > 0)
1410             columns = value;
1411         }
1412
1413       if (columns == 0)
1414         /* Use a reasonable default.  */
1415         columns = 80;
1416     }
1417
1418   /* Decide upon the title for the options that we are going to display.  */
1419   for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1420     {
1421       switch (flag & include_flags)
1422         {
1423         case 0:
1424           break;
1425
1426         case CL_TARGET:
1427           description = _("The following options are target specific");
1428           break;
1429         case CL_WARNING:
1430           description = _("The following options control compiler warning messages");
1431           break;
1432         case CL_OPTIMIZATION:
1433           description = _("The following options control optimizations");
1434           break;
1435         case CL_COMMON:
1436           description = _("The following options are language-independent");
1437           break;
1438         case CL_PARAMS:
1439           description = _("The --param option recognizes the following as parameters");
1440           break;
1441         default:
1442           if (i >= cl_lang_count)
1443             break;
1444           if (exclude_flags & all_langs_mask)
1445             description = _("The following options are specific to just the language ");
1446           else
1447             description = _("The following options are supported by the language ");
1448           descrip_extra = lang_names [i];
1449           break;
1450         }
1451     }
1452
1453   if (description == NULL)
1454     {
1455       if (any_flags == 0)
1456         {
1457           if (include_flags & CL_UNDOCUMENTED)
1458             description = _("The following options are not documented");
1459           else if (include_flags & CL_SEPARATE)
1460             description = _("The following options take separate arguments");
1461           else if (include_flags & CL_JOINED)
1462             description = _("The following options take joined arguments");
1463           else
1464             {
1465               internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1466                               include_flags);
1467               return;
1468             }
1469         }
1470       else
1471         {
1472           if (any_flags & all_langs_mask)
1473             description = _("The following options are language-related");
1474           else
1475             description = _("The following options are language-independent");
1476         }
1477     }
1478
1479   printf ("%s%s:\n", description, descrip_extra);
1480   print_filtered_help (include_flags, exclude_flags, any_flags, columns);
1481 }
1482
1483 /* Handle target- and language-independent options.  Return zero to
1484    generate an "unknown option" message.  Only options that need
1485    extra handling need to be listed here; if you simply want
1486    VALUE assigned to a variable, it happens automatically.  */
1487
1488 static int
1489 common_handle_option (size_t scode, const char *arg, int value,
1490                       unsigned int lang_mask, int kind ATTRIBUTE_UNUSED)
1491 {
1492   static bool verbose = false;
1493   enum opt_code code = (enum opt_code) scode;
1494
1495   switch (code)
1496     {
1497     case OPT__param:
1498       handle_param (arg);
1499       break;
1500
1501     case OPT_v:
1502       verbose = true;
1503       break;
1504
1505     case OPT_fhelp:
1506     case OPT__help:
1507       {
1508         unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1509         unsigned int undoc_mask;
1510         unsigned int i;
1511
1512         undoc_mask = (verbose | extra_warnings) ? 0 : CL_UNDOCUMENTED;
1513         /* First display any single language specific options.  */
1514         for (i = 0; i < cl_lang_count; i++)
1515           print_specific_help
1516             (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0);
1517         /* Next display any multi language specific options.  */
1518         print_specific_help (0, undoc_mask, all_langs_mask);
1519         /* Then display any remaining, non-language options.  */
1520         for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1521           print_specific_help (i, undoc_mask, 0);
1522         exit_after_options = true;
1523         break;
1524       }
1525
1526     case OPT_ftarget_help:
1527     case OPT__target_help:
1528       print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0);
1529       exit_after_options = true;
1530
1531       /* Allow the target a chance to give the user some additional information.  */
1532       if (targetm.target_help)
1533         targetm.target_help ();
1534       break;
1535
1536     case OPT_fhelp_:
1537     case OPT__help_:
1538       {
1539         const char * a = arg;
1540         unsigned int include_flags = 0;
1541         /* Note - by default we include undocumented options when listing
1542            specific classes.  If you only want to see documented options
1543            then add ",^undocumented" to the --help= option.  E.g.:
1544
1545            --help=target,^undocumented  */
1546         unsigned int exclude_flags = 0;
1547
1548         /* Walk along the argument string, parsing each word in turn.
1549            The format is:
1550            arg = [^]{word}[,{arg}]
1551            word = {optimizers|target|warnings|undocumented|
1552                    params|common|<language>}  */
1553         while (* a != 0)
1554           {
1555             static struct
1556             {
1557               const char * string;
1558               unsigned int flag;
1559             }
1560             specifics[] =
1561             {
1562               { "optimizers", CL_OPTIMIZATION },
1563               { "target", CL_TARGET },
1564               { "warnings", CL_WARNING },
1565               { "undocumented", CL_UNDOCUMENTED },
1566               { "params", CL_PARAMS },
1567               { "joined", CL_JOINED },
1568               { "separate", CL_SEPARATE },
1569               { "common", CL_COMMON },
1570               { NULL, 0 }
1571             };
1572             unsigned int * pflags;
1573             const char * comma;
1574             unsigned int lang_flag, specific_flag;
1575             unsigned int len;
1576             unsigned int i;
1577
1578             if (* a == '^')
1579               {
1580                 ++ a;
1581                 pflags = & exclude_flags;
1582               }
1583             else
1584               pflags = & include_flags;
1585
1586             comma = strchr (a, ',');
1587             if (comma == NULL)
1588               len = strlen (a);
1589             else
1590               len = comma - a;
1591             if (len == 0)
1592               {
1593                 a = comma + 1;
1594                 continue;
1595               }
1596
1597             /* Check to see if the string matches an option class name.  */
1598             for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1599               if (strncasecmp (a, specifics[i].string, len) == 0)
1600                 {
1601                   specific_flag = specifics[i].flag;
1602                   break;
1603                 }
1604
1605             /* Check to see if the string matches a language name.
1606                Note - we rely upon the alpha-sorted nature of the entries in
1607                the lang_names array, specifically that shorter names appear
1608                before their longer variants.  (i.e. C before C++).  That way
1609                when we are attempting to match --help=c for example we will
1610                match with C first and not C++.  */
1611             for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1612               if (strncasecmp (a, lang_names[i], len) == 0)
1613                 {
1614                   lang_flag = 1U << i;
1615                   break;
1616                 }
1617
1618             if (specific_flag != 0)
1619               {
1620                 if (lang_flag == 0)
1621                   * pflags |= specific_flag;
1622                 else
1623                   {
1624                     /* The option's argument matches both the start of a
1625                        language name and the start of an option class name.
1626                        We have a special case for when the user has
1627                        specified "--help=c", but otherwise we have to issue
1628                        a warning.  */
1629                     if (strncasecmp (a, "c", len) == 0)
1630                       * pflags |= lang_flag;
1631                     else
1632                       fnotice (stderr,
1633                                "warning: --help argument %.*s is ambiguous, please be more specific\n",
1634                                len, a);
1635                   }
1636               }
1637             else if (lang_flag != 0)
1638               * pflags |= lang_flag;
1639             else
1640               fnotice (stderr,
1641                        "warning: unrecognized argument to --help= option: %.*s\n",
1642                        len, a);
1643
1644             if (comma == NULL)
1645               break;
1646             a = comma + 1;
1647           }
1648
1649         if (include_flags)
1650           print_specific_help (include_flags, exclude_flags, 0);
1651         exit_after_options = true;
1652         break;
1653       }
1654
1655     case OPT_fversion:
1656     case OPT__version:
1657       exit_after_options = true;
1658       break;
1659
1660     case OPT_G:
1661       g_switch_value = value;
1662       g_switch_set = true;
1663       break;
1664
1665     case OPT_O:
1666     case OPT_Os:
1667       /* Currently handled in a prescan.  */
1668       break;
1669
1670     case OPT_Werror_:
1671       enable_warning_as_error (arg, value, lang_mask);
1672       break;
1673
1674     case OPT_Wlarger_than_:
1675       /* This form corresponds to -Wlarger-than-.
1676          Kept for backward compatibility.
1677          Don't use it as the first argument of warning().  */
1678
1679     case OPT_Wlarger_than_eq:
1680       larger_than_size = value;
1681       warn_larger_than = value != -1;
1682       break;
1683
1684     case OPT_Wframe_larger_than_:
1685       frame_larger_than_size = value;
1686       warn_frame_larger_than = value != -1;
1687       break;
1688
1689     case OPT_Wstrict_aliasing:
1690       set_Wstrict_aliasing (value);
1691       break;
1692
1693     case OPT_Wstrict_aliasing_:
1694       warn_strict_aliasing = value;
1695       break;
1696
1697     case OPT_Wstrict_overflow:
1698       warn_strict_overflow = (value
1699                               ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1700                               : 0);
1701       break;
1702
1703     case OPT_Wstrict_overflow_:
1704       warn_strict_overflow = value;
1705       break;
1706
1707     case OPT_Wunused:
1708       warn_unused = value;
1709       break;
1710
1711     case OPT_aux_info:
1712     case OPT_aux_info_:
1713       aux_info_file_name = arg;
1714       flag_gen_aux_info = 1;
1715       break;
1716
1717     case OPT_auxbase:
1718       aux_base_name = arg;
1719       break;
1720
1721     case OPT_auxbase_strip:
1722       {
1723         char *tmp = xstrdup (arg);
1724         strip_off_ending (tmp, strlen (tmp));
1725         if (tmp[0])
1726           aux_base_name = tmp;
1727       }
1728       break;
1729
1730     case OPT_d:
1731       decode_d_option (arg);
1732       break;
1733
1734     case OPT_dumpbase:
1735       dump_base_name = arg;
1736       break;
1737
1738     case OPT_dumpdir:
1739       dump_dir_name = arg;
1740       break;
1741
1742     case OPT_falign_functions_:
1743       align_functions = value;
1744       break;
1745
1746     case OPT_falign_jumps_:
1747       align_jumps = value;
1748       break;
1749
1750     case OPT_falign_labels_:
1751       align_labels = value;
1752       break;
1753
1754     case OPT_falign_loops_:
1755       align_loops = value;
1756       break;
1757
1758     case OPT_fbranch_probabilities:
1759       flag_branch_probabilities_set = true;
1760       break;
1761
1762     case OPT_fcall_used_:
1763       fix_register (arg, 0, 1);
1764       break;
1765
1766     case OPT_fcall_saved_:
1767       fix_register (arg, 0, 0);
1768       break;
1769
1770     case OPT_fdbg_cnt_:
1771       dbg_cnt_process_opt (arg);
1772       break;
1773
1774     case OPT_fdbg_cnt_list:
1775       dbg_cnt_list_all_counters ();
1776       break;
1777
1778     case OPT_fdebug_prefix_map_:
1779       add_debug_prefix_map (arg);
1780       break;
1781
1782     case OPT_fdiagnostics_show_location_:
1783       if (!strcmp (arg, "once"))
1784         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
1785       else if (!strcmp (arg, "every-line"))
1786         diagnostic_prefixing_rule (global_dc)
1787           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
1788       else
1789         return 0;
1790       break;
1791
1792     case OPT_fdiagnostics_show_option:
1793       global_dc->show_option_requested = value;
1794       break;
1795
1796     case OPT_fdump_:
1797       if (!dump_switch_p (arg))
1798         return 0;
1799       break;
1800
1801     case OPT_fexcess_precision_:
1802       if (!strcmp (arg, "fast"))
1803         flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
1804       else if (!strcmp (arg, "standard"))
1805         flag_excess_precision_cmdline = EXCESS_PRECISION_STANDARD;
1806       else
1807         error ("unknown excess precision style \"%s\"", arg);
1808       break;
1809
1810     case OPT_ffast_math:
1811       set_fast_math_flags (value);
1812       break;
1813
1814     case OPT_funsafe_math_optimizations:
1815       set_unsafe_math_optimizations_flags (value);
1816       break;
1817
1818     case OPT_ffixed_:
1819       fix_register (arg, 1, 1);
1820       break;
1821
1822     case OPT_finline_limit_:
1823     case OPT_finline_limit_eq:
1824       set_param_value ("max-inline-insns-single", value / 2);
1825       set_param_value ("max-inline-insns-auto", value / 2);
1826       break;
1827
1828     case OPT_finstrument_functions_exclude_function_list_:
1829       add_comma_separated_to_vector
1830         (&flag_instrument_functions_exclude_functions, arg);
1831       break;
1832
1833     case OPT_finstrument_functions_exclude_file_list_:
1834       add_comma_separated_to_vector
1835         (&flag_instrument_functions_exclude_files, arg);
1836       break;
1837
1838     case OPT_fmessage_length_:
1839       pp_set_line_maximum_length (global_dc->printer, value);
1840       break;
1841
1842     case OPT_fpack_struct_:
1843       if (value <= 0 || (value & (value - 1)) || value > 16)
1844         error ("structure alignment must be a small power of two, not %d", value);
1845       else
1846         {
1847           initial_max_fld_align = value;
1848           maximum_field_alignment = value * BITS_PER_UNIT;
1849         }
1850       break;
1851
1852     case OPT_fpeel_loops:
1853       flag_peel_loops_set = true;
1854       break;
1855
1856     case OPT_fplugin_:
1857 #ifdef ENABLE_PLUGIN
1858       add_new_plugin (arg);
1859 #else
1860       error ("Plugin support is disabled.  Configure with --enable-plugin.");
1861 #endif
1862       break;
1863
1864     case OPT_fplugin_arg_:
1865 #ifdef ENABLE_PLUGIN
1866       parse_plugin_arg_opt (arg);
1867 #else
1868       error ("Plugin support is disabled.  Configure with --enable-plugin.");
1869 #endif
1870       break;
1871
1872     case OPT_fprofile_arcs:
1873       profile_arc_flag_set = true;
1874       break;
1875
1876     case OPT_finline_functions:
1877       flag_inline_functions_set = true;
1878       break;
1879
1880     case OPT_fprofile_dir_:
1881       profile_data_prefix = xstrdup (arg);
1882       break;
1883
1884     case OPT_fprofile_use_:
1885       profile_data_prefix = xstrdup (arg);
1886       flag_profile_use = true;
1887       value = true;
1888       /* No break here - do -fprofile-use processing. */
1889     case OPT_fprofile_use:
1890       if (!flag_branch_probabilities_set)
1891         flag_branch_probabilities = value;
1892       if (!flag_profile_values_set)
1893         flag_profile_values = value;
1894       if (!flag_unroll_loops_set)
1895         flag_unroll_loops = value;
1896       if (!flag_peel_loops_set)
1897         flag_peel_loops = value;
1898       if (!flag_tracer_set)
1899         flag_tracer = value;
1900       if (!flag_value_profile_transformations_set)
1901         flag_value_profile_transformations = value;
1902       if (!flag_inline_functions_set)
1903         flag_inline_functions = value;
1904       if (!flag_ipa_cp_set)
1905         flag_ipa_cp = value;
1906       if (!flag_ipa_cp_clone_set
1907           && value && flag_ipa_cp)
1908         flag_ipa_cp_clone = value;
1909       if (!flag_predictive_commoning_set)
1910         flag_predictive_commoning = value;
1911       if (!flag_unswitch_loops_set)
1912         flag_unswitch_loops = value;
1913       if (!flag_gcse_after_reload_set)
1914         flag_gcse_after_reload = value;
1915       break;
1916
1917     case OPT_fprofile_generate_:
1918       profile_data_prefix = xstrdup (arg);
1919       value = true;
1920       /* No break here - do -fprofile-generate processing. */
1921     case OPT_fprofile_generate:
1922       if (!profile_arc_flag_set)
1923         profile_arc_flag = value;
1924       if (!flag_profile_values_set)
1925         flag_profile_values = value;
1926       if (!flag_value_profile_transformations_set)
1927         flag_value_profile_transformations = value;
1928       if (!flag_inline_functions_set)
1929         flag_inline_functions = value;
1930       break;
1931
1932     case OPT_fprofile_values:
1933       flag_profile_values_set = true;
1934       break;
1935
1936     case OPT_fvisibility_:
1937       {
1938         if (!strcmp(arg, "default"))
1939           default_visibility = VISIBILITY_DEFAULT;
1940         else if (!strcmp(arg, "internal"))
1941           default_visibility = VISIBILITY_INTERNAL;
1942         else if (!strcmp(arg, "hidden"))
1943           default_visibility = VISIBILITY_HIDDEN;
1944         else if (!strcmp(arg, "protected"))
1945           default_visibility = VISIBILITY_PROTECTED;
1946         else
1947           error ("unrecognized visibility value \"%s\"", arg);
1948       }
1949       break;
1950
1951     case OPT_fvpt:
1952       flag_value_profile_transformations_set = true;
1953       break;
1954
1955     case OPT_frandom_seed:
1956       /* The real switch is -fno-random-seed.  */
1957       if (value)
1958         return 0;
1959       set_random_seed (NULL);
1960       break;
1961
1962     case OPT_frandom_seed_:
1963       set_random_seed (arg);
1964       break;
1965
1966     case OPT_fselective_scheduling:
1967     case OPT_fselective_scheduling2:
1968       sel_sched_switch_set = true;
1969       break;
1970
1971     case OPT_fsched_verbose_:
1972 #ifdef INSN_SCHEDULING
1973       fix_sched_param ("verbose", arg);
1974       break;
1975 #else
1976       return 0;
1977 #endif
1978
1979     case OPT_fsched_stalled_insns_:
1980       flag_sched_stalled_insns = value;
1981       if (flag_sched_stalled_insns == 0)
1982         flag_sched_stalled_insns = -1;
1983       break;
1984
1985     case OPT_fsched_stalled_insns_dep_:
1986       flag_sched_stalled_insns_dep = value;
1987       break;
1988
1989     case OPT_fstack_check_:
1990       if (!strcmp (arg, "no"))
1991         flag_stack_check = NO_STACK_CHECK;
1992       else if (!strcmp (arg, "generic"))
1993         /* This is the old stack checking method.  */
1994         flag_stack_check = STACK_CHECK_BUILTIN
1995                            ? FULL_BUILTIN_STACK_CHECK
1996                            : GENERIC_STACK_CHECK;
1997       else if (!strcmp (arg, "specific"))
1998         /* This is the new stack checking method.  */
1999         flag_stack_check = STACK_CHECK_BUILTIN
2000                            ? FULL_BUILTIN_STACK_CHECK
2001                            : STACK_CHECK_STATIC_BUILTIN
2002                              ? STATIC_BUILTIN_STACK_CHECK
2003                              : GENERIC_STACK_CHECK;
2004       else
2005         warning (0, "unknown stack check parameter \"%s\"", arg);
2006       break;
2007
2008     case OPT_fstack_check:
2009       /* This is the same as the "specific" mode above.  */
2010       if (value)
2011         flag_stack_check = STACK_CHECK_BUILTIN
2012                            ? FULL_BUILTIN_STACK_CHECK
2013                            : STACK_CHECK_STATIC_BUILTIN
2014                              ? STATIC_BUILTIN_STACK_CHECK
2015                              : GENERIC_STACK_CHECK;
2016       else
2017         flag_stack_check = NO_STACK_CHECK;
2018       break;
2019
2020     case OPT_fstack_limit:
2021       /* The real switch is -fno-stack-limit.  */
2022       if (value)
2023         return 0;
2024       stack_limit_rtx = NULL_RTX;
2025       break;
2026
2027     case OPT_fstack_limit_register_:
2028       {
2029         int reg = decode_reg_name (arg);
2030         if (reg < 0)
2031           error ("unrecognized register name \"%s\"", arg);
2032         else
2033           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
2034       }
2035       break;
2036
2037     case OPT_fstack_limit_symbol_:
2038       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
2039       break;
2040
2041     case OPT_ftree_vectorizer_verbose_:
2042       vect_set_verbosity_level (arg);
2043       break;
2044
2045     case OPT_ftls_model_:
2046       if (!strcmp (arg, "global-dynamic"))
2047         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
2048       else if (!strcmp (arg, "local-dynamic"))
2049         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
2050       else if (!strcmp (arg, "initial-exec"))
2051         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
2052       else if (!strcmp (arg, "local-exec"))
2053         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
2054       else
2055         warning (0, "unknown tls-model \"%s\"", arg);
2056       break;
2057
2058     case OPT_fira_algorithm_:
2059       if (!strcmp (arg, "CB"))
2060         flag_ira_algorithm = IRA_ALGORITHM_CB;
2061       else if (!strcmp (arg, "priority"))
2062         flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
2063       else
2064         warning (0, "unknown ira algorithm \"%s\"", arg);
2065       break;
2066
2067     case OPT_fira_region_:
2068       if (!strcmp (arg, "one"))
2069         flag_ira_region = IRA_REGION_ONE;
2070       else if (!strcmp (arg, "all"))
2071         flag_ira_region = IRA_REGION_ALL;
2072       else if (!strcmp (arg, "mixed"))
2073         flag_ira_region = IRA_REGION_MIXED;
2074       else
2075         warning (0, "unknown ira region \"%s\"", arg);
2076       break;
2077
2078     case OPT_fira_verbose_:
2079       flag_ira_verbose = value;
2080       break;
2081
2082     case OPT_ftracer:
2083       flag_tracer_set = true;
2084       break;
2085
2086     case OPT_fipa_cp:
2087       flag_ipa_cp_set = true;
2088       break;
2089
2090     case OPT_fipa_cp_clone:
2091       flag_ipa_cp_clone_set = true;
2092       break;
2093
2094     case OPT_fpredictive_commoning:
2095       flag_predictive_commoning_set = true;
2096       break;
2097
2098     case OPT_funswitch_loops:
2099       flag_unswitch_loops_set = true;
2100       break;
2101
2102     case OPT_fgcse_after_reload:
2103       flag_gcse_after_reload_set = true;
2104       break;
2105
2106     case OPT_funroll_loops:
2107       flag_unroll_loops_set = true;
2108       break;
2109
2110     case OPT_g:
2111       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
2112       break;
2113
2114     case OPT_gcoff:
2115       set_debug_level (SDB_DEBUG, false, arg);
2116       break;
2117
2118     case OPT_gdwarf_:
2119       if (value < 2 || value > 4)
2120         error ("dwarf version %d is not supported", value);
2121       else
2122         dwarf_version = value;
2123       set_debug_level (DWARF2_DEBUG, false, "");
2124       break;
2125
2126     case OPT_ggdb:
2127       set_debug_level (NO_DEBUG, 2, arg);
2128       break;
2129
2130     case OPT_gstabs:
2131     case OPT_gstabs_:
2132       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
2133       break;
2134
2135     case OPT_gvms:
2136       set_debug_level (VMS_DEBUG, false, arg);
2137       break;
2138
2139     case OPT_gxcoff:
2140     case OPT_gxcoff_:
2141       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
2142       break;
2143
2144     case OPT_o:
2145       asm_file_name = arg;
2146       break;
2147
2148     case OPT_pedantic_errors:
2149       flag_pedantic_errors = pedantic = 1;
2150       break;
2151
2152     case OPT_fsee:
2153     case OPT_fcse_skip_blocks:
2154     case OPT_floop_optimize:
2155     case OPT_frerun_loop_opt:
2156     case OPT_fsched2_use_traces:
2157     case OPT_fstrength_reduce:
2158     case OPT_ftree_store_copy_prop:
2159     case OPT_fforce_addr:
2160     case OPT_ftree_salias:
2161     case OPT_ftree_store_ccp:
2162     case OPT_Wunreachable_code:
2163     case OPT_fargument_alias:
2164     case OPT_fargument_noalias:
2165     case OPT_fargument_noalias_anything:
2166     case OPT_fargument_noalias_global:
2167       /* These are no-ops, preserved for backward compatibility.  */
2168       break;
2169
2170     case OPT_fuse_linker_plugin:
2171       /* No-op. Used by the driver and passed to us because it starts with f.*/
2172       break;
2173
2174     default:
2175       /* If the flag was handled in a standard way, assume the lack of
2176          processing here is intentional.  */
2177       gcc_assert (cl_options[scode].flag_var);
2178       break;
2179     }
2180
2181   return 1;
2182 }
2183
2184 /* Handle --param NAME=VALUE.  */
2185 static void
2186 handle_param (const char *carg)
2187 {
2188   char *equal, *arg;
2189   int value;
2190
2191   arg = xstrdup (carg);
2192   equal = strchr (arg, '=');
2193   if (!equal)
2194     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
2195   else
2196     {
2197       value = integral_argument (equal + 1);
2198       if (value == -1)
2199         error ("invalid --param value %qs", equal + 1);
2200       else
2201         {
2202           *equal = '\0';
2203           set_param_value (arg, value);
2204         }
2205     }
2206
2207   free (arg);
2208 }
2209
2210 /* Used to set the level of strict aliasing warnings,
2211    when no level is specified (i.e., when -Wstrict-aliasing, and not
2212    -Wstrict-aliasing=level was given).
2213    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2214    and 0 otherwise.  After calling this function, wstrict_aliasing will be
2215    set to the default value of -Wstrict_aliasing=level, currently 3.  */
2216 void
2217 set_Wstrict_aliasing (int onoff)
2218 {
2219   gcc_assert (onoff == 0 || onoff == 1);
2220   if (onoff != 0)
2221     warn_strict_aliasing = 3;
2222   else
2223     warn_strict_aliasing = 0;
2224 }
2225
2226 /* The following routines are useful in setting all the flags that
2227    -ffast-math and -fno-fast-math imply.  */
2228 void
2229 set_fast_math_flags (int set)
2230 {
2231   flag_unsafe_math_optimizations = set;
2232   set_unsafe_math_optimizations_flags (set);
2233   flag_finite_math_only = set;
2234   flag_errno_math = !set;
2235   if (set)
2236     {
2237       flag_signaling_nans = 0;
2238       flag_rounding_math = 0;
2239       flag_cx_limited_range = 1;
2240     }
2241 }
2242
2243 /* When -funsafe-math-optimizations is set the following
2244    flags are set as well.  */
2245 void
2246 set_unsafe_math_optimizations_flags (int set)
2247 {
2248   flag_trapping_math = !set;
2249   flag_signed_zeros = !set;
2250   flag_associative_math = set;
2251   flag_reciprocal_math = set;
2252 }
2253
2254 /* Return true iff flags are set as if -ffast-math.  */
2255 bool
2256 fast_math_flags_set_p (void)
2257 {
2258   return (!flag_trapping_math
2259           && flag_unsafe_math_optimizations
2260           && flag_finite_math_only
2261           && !flag_signed_zeros
2262           && !flag_errno_math);
2263 }
2264
2265 /* Return true iff flags are set as if -ffast-math but using the flags stored
2266    in the struct cl_optimization structure.  */
2267 bool
2268 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2269 {
2270   return (!opt->flag_trapping_math
2271           && opt->flag_unsafe_math_optimizations
2272           && opt->flag_finite_math_only
2273           && !opt->flag_signed_zeros
2274           && !opt->flag_errno_math);
2275 }
2276
2277 /* Handle a debug output -g switch.  EXTENDED is true or false to support
2278    extended output (2 is special and means "-ggdb" was given).  */
2279 static void
2280 set_debug_level (enum debug_info_type type, int extended, const char *arg)
2281 {
2282   static bool type_explicit;
2283
2284   use_gnu_debug_info_extensions = extended;
2285
2286   if (type == NO_DEBUG)
2287     {
2288       if (write_symbols == NO_DEBUG)
2289         {
2290           write_symbols = PREFERRED_DEBUGGING_TYPE;
2291
2292           if (extended == 2)
2293             {
2294 #ifdef DWARF2_DEBUGGING_INFO
2295               write_symbols = DWARF2_DEBUG;
2296 #elif defined DBX_DEBUGGING_INFO
2297               write_symbols = DBX_DEBUG;
2298 #endif
2299             }
2300
2301           if (write_symbols == NO_DEBUG)
2302             warning (0, "target system does not support debug output");
2303         }
2304     }
2305   else
2306     {
2307       /* Does it conflict with an already selected type?  */
2308       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
2309         error ("debug format \"%s\" conflicts with prior selection",
2310                debug_type_names[type]);
2311       write_symbols = type;
2312       type_explicit = true;
2313     }
2314
2315   /* A debug flag without a level defaults to level 2.  */
2316   if (*arg == '\0')
2317     {
2318       if (!debug_info_level)
2319         debug_info_level = DINFO_LEVEL_NORMAL;
2320     }
2321   else
2322     {
2323       int argval = integral_argument (arg);
2324       if (argval == -1)
2325         error ("unrecognised debug output level \"%s\"", arg);
2326       else if (argval > 3)
2327         error ("debug output level %s is too high", arg);
2328       else
2329         debug_info_level = (enum debug_info_level) argval;
2330     }
2331 }
2332
2333 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
2334    a simple on-off switch.  */
2335
2336 int
2337 option_enabled (int opt_idx)
2338 {
2339   const struct cl_option *option = &(cl_options[opt_idx]);
2340
2341   if (option->flag_var)
2342     switch (option->var_type)
2343       {
2344       case CLVC_BOOLEAN:
2345         return *(int *) option->flag_var != 0;
2346
2347       case CLVC_EQUAL:
2348         return *(int *) option->flag_var == option->var_value;
2349
2350       case CLVC_BIT_CLEAR:
2351         return (*(int *) option->flag_var & option->var_value) == 0;
2352
2353       case CLVC_BIT_SET:
2354         return (*(int *) option->flag_var & option->var_value) != 0;
2355
2356       case CLVC_STRING:
2357         break;
2358       }
2359   return -1;
2360 }
2361
2362 /* Fill STATE with the current state of option OPTION.  Return true if
2363    there is some state to store.  */
2364
2365 bool
2366 get_option_state (int option, struct cl_option_state *state)
2367 {
2368   if (cl_options[option].flag_var == 0)
2369     return false;
2370
2371   switch (cl_options[option].var_type)
2372     {
2373     case CLVC_BOOLEAN:
2374     case CLVC_EQUAL:
2375       state->data = cl_options[option].flag_var;
2376       state->size = sizeof (int);
2377       break;
2378
2379     case CLVC_BIT_CLEAR:
2380     case CLVC_BIT_SET:
2381       state->ch = option_enabled (option);
2382       state->data = &state->ch;
2383       state->size = 1;
2384       break;
2385
2386     case CLVC_STRING:
2387       state->data = *(const char **) cl_options[option].flag_var;
2388       if (state->data == 0)
2389         state->data = "";
2390       state->size = strlen ((const char *) state->data) + 1;
2391       break;
2392     }
2393   return true;
2394 }
2395
2396 /* Set *OPTION according to VALUE and ARG.  */
2397
2398 void
2399 set_option (int opt_index, int value, const char *arg, int kind)
2400 {
2401   const struct cl_option *option = &cl_options[opt_index];
2402
2403   if (!option->flag_var)
2404     return;
2405
2406   switch (option->var_type)
2407     {
2408     case CLVC_BOOLEAN:
2409         *(int *) option->flag_var = value;
2410         break;
2411
2412     case CLVC_EQUAL:
2413         *(int *) option->flag_var = (value
2414                                      ? option->var_value
2415                                      : !option->var_value);
2416         break;
2417
2418     case CLVC_BIT_CLEAR:
2419     case CLVC_BIT_SET:
2420         if ((value != 0) == (option->var_type == CLVC_BIT_SET))
2421           *(int *) option->flag_var |= option->var_value;
2422         else
2423           *(int *) option->flag_var &= ~option->var_value;
2424         if (option->flag_var == &target_flags)
2425           target_flags_explicit |= option->var_value;
2426         break;
2427
2428     case CLVC_STRING:
2429         *(const char **) option->flag_var = arg;
2430         break;
2431     }
2432
2433   if ((diagnostic_t)kind != DK_UNSPECIFIED)
2434     diagnostic_classify_diagnostic (global_dc, opt_index, (diagnostic_t)kind);
2435 }
2436
2437
2438 /* Callback function, called when -Werror= enables a warning.  */
2439
2440 static void (*warning_as_error_callback) (int) = NULL;
2441
2442 /* Register a callback for enable_warning_as_error calls.  */
2443
2444 void
2445 register_warning_as_error_callback (void (*callback) (int))
2446 {
2447   gcc_assert (warning_as_error_callback == NULL || callback == NULL);
2448   warning_as_error_callback = callback;
2449 }
2450
2451 /* Enable a warning option as an error.  This is used by -Werror= and
2452    also by legacy Werror-implicit-function-declaration.  */
2453
2454 void
2455 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask)
2456 {
2457   char *new_option;
2458   int option_index;
2459
2460   new_option = XNEWVEC (char, strlen (arg) + 2);
2461   new_option[0] = 'W';
2462   strcpy (new_option + 1, arg);
2463   option_index = find_opt (new_option, lang_mask);
2464   if (option_index == N_OPTS)
2465     {
2466       error ("-Werror=%s: No option -%s", arg, new_option);
2467     }
2468   else
2469     {
2470       const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
2471
2472       diagnostic_classify_diagnostic (global_dc, option_index, kind);
2473       if (kind == DK_ERROR)
2474         {
2475           const struct cl_option * const option = cl_options + option_index;
2476
2477           /* -Werror=foo implies -Wfoo.  */
2478           if (option->var_type == CLVC_BOOLEAN)
2479             handle_option (option_index, value, arg, lang_mask, (int)kind);
2480
2481           if (warning_as_error_callback)
2482             warning_as_error_callback (option_index);
2483         }
2484     }
2485   free (new_option);
2486 }