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