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 "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 bool common_handle_option (const struct cl_decoded_option *decoded,
 375                                   unsigned int lang_mask, int kind,
 376                                   const struct cl_option_handlers *handlers);
 377 static void handle_param (const char *);
 378 static char *write_langs (unsigned int lang_mask);
 379 static void complain_wrong_lang (const struct cl_decoded_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 DECODED does not apply to this front end (mask
 413    LANG_MASK).  */
 414 static void
 415 complain_wrong_lang (const struct cl_decoded_option *decoded,
 416                      unsigned int lang_mask)
 417 {
 418   const struct cl_option *option = &cl_options[decoded->opt_index];
 419   const char *text = decoded->orig_option_with_args_text;
 420   char *ok_langs = NULL, *bad_lang = NULL;
 421   unsigned int opt_flags = option->flags;
 422
 423   if (!lang_hooks.complain_wrong_lang_p (option))
 424     return;
 425
 426   opt_flags &= ((1U << cl_lang_count) - 1) | CL_DRIVER;
 427   if (opt_flags != CL_DRIVER)
 428     ok_langs = write_langs (opt_flags);
 429   if (lang_mask != CL_DRIVER)
 430     bad_lang = write_langs (lang_mask);
 431
 432   if (opt_flags == CL_DRIVER)
 433     error ("command line option %qs is valid for the driver but not for %s",
 434            text, bad_lang);
 435   else if (lang_mask == CL_DRIVER)
 436     gcc_unreachable ();
 437   else
 438     /* Eventually this should become a hard error IMO.  */
 439     warning (0, "command line option %qs is valid for %s but not for %s",
 440              text, ok_langs, bad_lang);
 441
 442   free (ok_langs);
 443   free (bad_lang);
 444 }
 445
 446 /* Buffer the unknown option described by the string OPT.  Currently,
 447    we only complain about unknown -Wno-* options if they may have
 448    prevented a diagnostic. Otherwise, we just ignore them.
 449    Note that if we do complain, it is only as a warning, not an error;
 450    passing the compiler an unrecognised -Wno-* option should never
 451    change whether the compilation succeeds or fails.  */
 452
 453 static void postpone_unknown_option_warning(const char *opt)
 454 {
 455   VEC_safe_push (const_char_p, heap, ignored_options, opt);
 456 }
 457
 458 /* Produce a warning for each option previously buffered.  */
 459
 460 void print_ignored_options (void)
 461 {
 462   location_t saved_loc = input_location;
 463
 464   input_location = 0;
 465
 466   while (!VEC_empty (const_char_p, ignored_options))
 467     {
 468       const char *opt;
 469       opt = VEC_pop (const_char_p, ignored_options);
 470       warning (0, "unrecognized command line option \"%s\"", opt);
 471     }
 472
 473   input_location = saved_loc;
 474 }
 475
 476 /* Handle an unknown option DECODED, returning true if an error should be
 477    given.  */
 478
 479 static bool
 480 unknown_option_callback (const struct cl_decoded_option *decoded)
 481 {
 482   const char *opt = decoded->arg;
 483
 484   if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
 485       && !(decoded->errors & CL_ERR_NEGATIVE))
 486     {
 487       /* We don't generate warnings for unknown -Wno-* options unless
 488          we issue diagnostics.  */
 489       postpone_unknown_option_warning (opt);
 490       return false;
 491     }
 492   else
 493     return true;
 494 }
 495
 496 /* Note that an option DECODED has been successfully handled with a
 497    handler for mask MASK.  */
 498
 499 static void
 500 post_handling_callback (const struct cl_decoded_option *decoded ATTRIBUTE_UNUSED,
 501                         unsigned int mask ATTRIBUTE_UNUSED)
 502 {
 503 #ifdef ENABLE_LTO
 504   lto_register_user_option (decoded->opt_index, decoded->arg,
 505                             decoded->value, mask);
 506 #endif
 507 }
 508
 509 /* Handle a front-end option; arguments and return value as for
 510    handle_option.  */
 511
 512 static bool
 513 lang_handle_option (const struct cl_decoded_option *decoded,
 514                     unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
 515                     const struct cl_option_handlers *handlers)
 516 {
 517   gcc_assert (decoded->canonical_option_num_elements <= 2);
 518   return lang_hooks.handle_option (decoded->opt_index, decoded->arg,
 519                                    decoded->value, kind, handlers);
 520 }
 521
 522 /* Handle a back-end option; arguments and return value as for
 523    handle_option.  */
 524
 525 static bool
 526 target_handle_option (const struct cl_decoded_option *decoded,
 527                       unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
 528                       const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
 529 {
 530   gcc_assert (decoded->canonical_option_num_elements <= 2);
 531   gcc_assert (kind == DK_UNSPECIFIED);
 532   return targetm.handle_option (decoded->opt_index, decoded->arg,
 533                                 decoded->value);
 534 }
 535
 536 /* Handle FILENAME from the command line.  */
 537 static void
 538 add_input_filename (const char *filename)
 539 {
 540   num_in_fnames++;
 541   in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
 542   in_fnames[num_in_fnames - 1] = filename;
 543 }
 544
 545 /* Add comma-separated strings to a char_p vector.  */
 546
 547 static void
 548 add_comma_separated_to_vector (VEC(char_p,heap) **pvec, const char* arg)
 549 {
 550   char *tmp;
 551   char *r;
 552   char *w;
 553   char *token_start;
 554
 555   /* We never free this string.  */
 556   tmp = xstrdup (arg);
 557
 558   r = tmp;
 559   w = tmp;
 560   token_start = tmp;
 561
 562   while (*r != '\0')
 563     {
 564       if (*r == ',')
 565         {
 566           *w++ = '\0';
 567           ++r;
 568           VEC_safe_push (char_p, heap, *pvec, token_start);
 569           token_start = w;
 570         }
 571       if (*r == '\\' && r[1] == ',')
 572         {
 573           *w++ = ',';
 574           r += 2;
 575         }
 576       else
 577         *w++ = *r++;
 578     }
 579   if (*token_start != '\0')
 580     VEC_safe_push (char_p, heap, *pvec, token_start);
 581 }
 582
 583 /* Return whether we should exclude FNDECL from instrumentation.  */
 584
 585 bool
 586 flag_instrument_functions_exclude_p (tree fndecl)
 587 {
 588   if (VEC_length (char_p, flag_instrument_functions_exclude_functions) > 0)
 589     {
 590       const char *name;
 591       int i;
 592       char *s;
 593
 594       name = lang_hooks.decl_printable_name (fndecl, 0);
 595       FOR_EACH_VEC_ELT (char_p, flag_instrument_functions_exclude_functions,
 596                         i, s)
 597         if (strstr (name, s) != NULL)
 598           return true;
 599     }
 600
 601   if (VEC_length (char_p, flag_instrument_functions_exclude_files) > 0)
 602     {
 603       const char *name;
 604       int i;
 605       char *s;
 606
 607       name = DECL_SOURCE_FILE (fndecl);
 608       FOR_EACH_VEC_ELT (char_p, flag_instrument_functions_exclude_files, i, s)
 609         if (strstr (name, s) != NULL)
 610           return true;
 611     }
 612
 613   return false;
 614 }
 615
 616
 617 /* Handle the vector of command line options.  LANG_MASK
 618    contains has a single bit set representing the current
 619    language.  HANDLERS describes what functions to call for the options.  */
 620 static void
 621 read_cmdline_options (struct cl_decoded_option *decoded_options,
 622                       unsigned int decoded_options_count,
 623                       unsigned int lang_mask,
 624                       const struct cl_option_handlers *handlers)
 625 {
 626   unsigned int i;
 627
 628   for (i = 1; i < decoded_options_count; i++)
 629     {
 630       if (decoded_options[i].opt_index == OPT_SPECIAL_input_file)
 631         {
 632           if (main_input_filename == NULL)
 633             {
 634               main_input_filename = decoded_options[i].arg;
 635               main_input_baselength
 636                 = base_of_path (main_input_filename, &main_input_basename);
 637             }
 638           add_input_filename (decoded_options[i].arg);
 639           continue;
 640         }
 641
 642       read_cmdline_option (decoded_options + i, lang_mask, handlers);
 643     }
 644 }
 645
 646 /* Parse command line options and set default flag values.  Do minimal
 647    options processing.  The decoded options are placed in *DECODED_OPTIONS
 648    and *DECODED_OPTIONS_COUNT.  */
 649 void
 650 decode_options (unsigned int argc, const char **argv,
 651                 struct cl_decoded_option **decoded_options,
 652                 unsigned int *decoded_options_count)
 653 {
 654   static bool first_time_p = true;
 655   static int initial_min_crossjump_insns;
 656   static int initial_max_fields_for_field_sensitive;
 657   static int initial_loop_invariant_max_bbs_in_loop;
 658   static unsigned int initial_lang_mask;
 659   struct cl_option_handlers handlers;
 660
 661   unsigned int i, lang_mask;
 662   int opt1;
 663   int opt2;
 664   int opt3;
 665   int opt1_max;
 666   int ofast = 0;
 667
 668   if (first_time_p)
 669     {
 670       /* Perform language-specific options initialization.  */
 671       initial_lang_mask = lang_mask = lang_hooks.option_lang_mask ();
 672
 673       lang_hooks.initialize_diagnostics (global_dc);
 674
 675       /* Save initial values of parameters we reset.  */
 676       initial_min_crossjump_insns
 677         = compiler_params[PARAM_MIN_CROSSJUMP_INSNS].value;
 678       initial_max_fields_for_field_sensitive
 679         = compiler_params[PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE].value;
 680       initial_loop_invariant_max_bbs_in_loop
 681         = compiler_params[PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP].value;
 682     }
 683   else
 684     lang_mask = initial_lang_mask;
 685
 686   decode_cmdline_options_to_array (argc, argv,
 687                                    lang_mask | CL_COMMON | CL_TARGET,
 688                                    decoded_options, decoded_options_count);
 689   if (first_time_p)
 690     /* Perform language-specific options initialization.  */
 691     lang_hooks.init_options (*decoded_options_count, *decoded_options);
 692
 693   handlers.unknown_option_callback = unknown_option_callback;
 694   handlers.wrong_lang_callback = complain_wrong_lang;
 695   handlers.post_handling_callback = post_handling_callback;
 696   handlers.num_handlers = 3;
 697   handlers.handlers[0].handler = lang_handle_option;
 698   handlers.handlers[0].mask = lang_mask;
 699   handlers.handlers[1].handler = common_handle_option;
 700   handlers.handlers[1].mask = CL_COMMON;
 701   handlers.handlers[2].handler = target_handle_option;
 702   handlers.handlers[2].mask = CL_TARGET;
 703
 704   /* Scan to see what optimization level has been specified.  That will
 705      determine the default value of many flags.  */
 706   for (i = 1; i < *decoded_options_count; i++)
 707     {
 708       struct cl_decoded_option *opt = &(*decoded_options)[i];
 709       switch (opt->opt_index)
 710         {
 711         case OPT_O:
 712           if (*opt->arg == '\0')
 713             {
 714               optimize = 1;
 715               optimize_size = 0;
 716               ofast = 0;
 717             }
 718           else
 719             {
 720               const int optimize_val = integral_argument (opt->arg);
 721               if (optimize_val == -1)
 722                 error ("argument to %qs should be a non-negative integer",
 723                        "-O");
 724               else
 725                 {
 726                   optimize = optimize_val;
 727                   if ((unsigned int) optimize > 255)
 728                     optimize = 255;
 729                   optimize_size = 0;
 730                   ofast = 0;
 731                 }
 732             }
 733           break;
 734
 735         case OPT_Os:
 736           optimize_size = 1;
 737
 738           /* Optimizing for size forces optimize to be 2.  */
 739           optimize = 2;
 740           ofast = 0;
 741           break;
 742
 743         case OPT_Ofast:
 744           /* -Ofast only adds flags to -O3.  */
 745           optimize_size = 0;
 746           optimize = 3;
 747           ofast = 1;
 748           break;
 749
 750         default:
 751           /* Ignore other options in this prescan.  */
 752           break;
 753         }
 754     }
 755
 756   /* Use priority coloring if cover classes is not defined for the
 757      target.  */
 758   if (targetm.ira_cover_classes == NULL)
 759     flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
 760
 761   /* -O1 optimizations.  */
 762   opt1 = (optimize >= 1);
 763   flag_defer_pop = opt1;
 764 #ifdef DELAY_SLOTS
 765   flag_delayed_branch = opt1;
 766 #endif
 767 #ifdef CAN_DEBUG_WITHOUT_FP
 768   flag_omit_frame_pointer = opt1;
 769 #endif
 770   flag_guess_branch_prob = opt1;
 771   flag_cprop_registers = opt1;
 772   flag_forward_propagate = opt1;
 773   flag_if_conversion = opt1;
 774   flag_if_conversion2 = opt1;
 775   flag_ipa_pure_const = opt1;
 776   flag_ipa_reference = opt1;
 777   flag_ipa_profile = opt1;
 778   flag_merge_constants = opt1;
 779   flag_split_wide_types = opt1;
 780   flag_tree_ccp = opt1;
 781   flag_tree_bit_ccp = opt1;
 782   flag_tree_dce = opt1;
 783   flag_tree_dom = opt1;
 784   flag_tree_dse = opt1;
 785   flag_tree_ter = opt1;
 786   flag_tree_sra = opt1;
 787   flag_tree_copyrename = opt1;
 788   flag_tree_fre = opt1;
 789   flag_tree_copy_prop = opt1;
 790   flag_tree_sink = opt1;
 791   flag_tree_ch = opt1;
 792
 793   /* -O2 optimizations.  */
 794   opt2 = (optimize >= 2);
 795   flag_inline_small_functions = opt2;
 796   flag_indirect_inlining = opt2;
 797   flag_partial_inlining = opt2;
 798   flag_thread_jumps = opt2;
 799   flag_crossjumping = opt2;
 800   flag_optimize_sibling_calls = opt2;
 801   flag_cse_follow_jumps = opt2;
 802   flag_gcse = opt2;
 803   flag_expensive_optimizations = opt2;
 804   flag_rerun_cse_after_loop = opt2;
 805   flag_caller_saves = opt2;
 806   flag_peephole2 = opt2;
 807 #ifdef INSN_SCHEDULING
 808   /* Only run the pre-regalloc scheduling pass if optimizing for speed.  */
 809   flag_schedule_insns = opt2 && ! optimize_size;
 810   flag_schedule_insns_after_reload = opt2;
 811 #endif
 812   flag_regmove = opt2;
 813   flag_strict_aliasing = opt2;
 814   flag_strict_overflow = opt2;
 815   flag_reorder_blocks = opt2;
 816   flag_reorder_functions = opt2;
 817   flag_tree_vrp = opt2;
 818   flag_tree_builtin_call_dce = opt2;
 819   flag_tree_pre = opt2;
 820   flag_tree_switch_conversion = opt2;
 821   flag_ipa_cp = opt2;
 822   flag_ipa_sra = opt2;
 823
 824   /* Track fields in field-sensitive alias analysis.  */
 825   set_param_value ("max-fields-for-field-sensitive",
 826                    (opt2) ? 100 : initial_max_fields_for_field_sensitive);
 827
 828   /* For -O1 only do loop invariant motion for very small loops.  */
 829   set_param_value ("loop-invariant-max-bbs-in-loop",
 830                    (opt2) ? initial_loop_invariant_max_bbs_in_loop : 1000);
 831
 832   /* -O3 optimizations.  */
 833   opt3 = (optimize >= 3);
 834   flag_tree_loop_distribute_patterns = opt3;
 835   flag_predictive_commoning = opt3;
 836   flag_inline_functions = opt3;
 837   flag_unswitch_loops = opt3;
 838   flag_gcse_after_reload = opt3;
 839   flag_tree_vectorize = opt3;
 840   flag_ipa_cp_clone = opt3;
 841   if (flag_ipa_cp_clone)
 842     flag_ipa_cp = 1;
 843
 844   /* Just -O1/-O0 optimizations.  */
 845   opt1_max = (optimize <= 1);
 846   align_loops = opt1_max;
 847   align_jumps = opt1_max;
 848   align_labels = opt1_max;
 849   align_functions = opt1_max;
 850
 851   if (optimize_size)
 852     {
 853       /* Inlining of functions reducing size is a good idea regardless of them
 854          being declared inline.  */
 855       flag_inline_functions = 1;
 856
 857       /* Basic optimization options.  */
 858       optimize_size = 1;
 859       if (optimize > 2)
 860         optimize = 2;
 861
 862       /* We want to crossjump as much as possible.  */
 863       set_param_value ("min-crossjump-insns", 1);
 864     }
 865   else
 866     set_param_value ("min-crossjump-insns", initial_min_crossjump_insns);
 867
 868   /* -Ofast adds optimizations to -O3.  */
 869   if (ofast)
 870     {
 871       /* Which is -ffast-math for now.  */
 872       set_fast_math_flags (1);
 873       /* Allow targets to enable extra options with -Ofast
 874          before general options processing so disabling them
 875          again afterwards works.  */
 876       targetm.handle_ofast ();
 877     }
 878
 879   /* Enable -Werror=coverage-mismatch by default */
 880   enable_warning_as_error ("coverage-mismatch", 1, lang_mask, &handlers);
 881
 882   if (first_time_p)
 883     {
 884       /* Initialize whether `char' is signed.  */
 885       flag_signed_char = DEFAULT_SIGNED_CHAR;
 886       /* Set this to a special "uninitialized" value.  The actual default is
 887          set after target options have been processed.  */
 888       flag_short_enums = 2;
 889
 890       /* Initialize target_flags before
 891          targetm.target_option.optimization so the latter can modify
 892          it.  */
 893       target_flags = targetm.default_target_flags;
 894
 895       /* Some targets have ABI-specified unwind tables.  */
 896       flag_unwind_tables = targetm.unwind_tables_default;
 897     }
 898
 899 #ifdef ENABLE_LTO
 900   /* Clear any options currently held for LTO.  */
 901   lto_clear_user_options ();
 902 #endif
 903
 904   /* Allow default optimizations to be specified on a per-machine basis.  */
 905   targetm.target_option.optimization (optimize, optimize_size);
 906
 907   read_cmdline_options (*decoded_options, *decoded_options_count, lang_mask,
 908                         &handlers);
 909
 910   if (dump_base_name && ! IS_ABSOLUTE_PATH (dump_base_name))
 911     {
 912       /* First try to make DUMP_BASE_NAME relative to the DUMP_DIR_NAME
 913          directory.  Then try to make DUMP_BASE_NAME relative to the
 914          AUX_BASE_NAME directory, typically the directory to contain
 915          the object file.  */
 916       if (dump_dir_name)
 917         dump_base_name = concat (dump_dir_name, dump_base_name, NULL);
 918       else if (aux_base_name)
 919         {
 920           const char *aux_base;
 921
 922           base_of_path (aux_base_name, &aux_base);
 923           if (aux_base_name != aux_base)
 924             {
 925               int dir_len = aux_base - aux_base_name;
 926               char *new_dump_base_name =
 927                 XNEWVEC (char, strlen(dump_base_name) + dir_len + 1);
 928
 929               /* Copy directory component from AUX_BASE_NAME.  */
 930               memcpy (new_dump_base_name, aux_base_name, dir_len);
 931               /* Append existing DUMP_BASE_NAME.  */
 932               strcpy (new_dump_base_name + dir_len, dump_base_name);
 933               dump_base_name = new_dump_base_name;
 934             }
 935         }
 936     }
 937
 938   /* Handle related options for unit-at-a-time, toplevel-reorder, and
 939      section-anchors.  */
 940   if (!flag_unit_at_a_time)
 941     {
 942       if (flag_section_anchors == 1)
 943         error ("Section anchors must be disabled when unit-at-a-time "
 944                "is disabled.");
 945       flag_section_anchors = 0;
 946       if (flag_toplevel_reorder == 1)
 947         error ("Toplevel reorder must be disabled when unit-at-a-time "
 948                "is disabled.");
 949       flag_toplevel_reorder = 0;
 950     }
 951
 952   /* -Wmissing-noreturn is alias for -Wsuggest-attribute=noreturn.  */
 953   if (warn_missing_noreturn)
 954     warn_suggest_attribute_noreturn = true;
 955
 956   /* Unless the user has asked for section anchors, we disable toplevel
 957      reordering at -O0 to disable transformations that might be surprising
 958      to end users and to get -fno-toplevel-reorder tested.  */
 959   if (!optimize && flag_toplevel_reorder == 2 && flag_section_anchors != 1)
 960     {
 961       flag_toplevel_reorder = 0;
 962       flag_section_anchors = 0;
 963     }
 964   if (!flag_toplevel_reorder)
 965     {
 966       if (flag_section_anchors == 1)
 967         error ("section anchors must be disabled when toplevel reorder"
 968                " is disabled");
 969       flag_section_anchors = 0;
 970     }
 971
 972   if (first_time_p)
 973     {
 974       if (flag_pie)
 975         flag_pic = flag_pie;
 976       if (flag_pic && !flag_pie)
 977         flag_shlib = 1;
 978       first_time_p = false;
 979     }
 980
 981   if (optimize == 0)
 982     {
 983       /* Inlining does not work if not optimizing,
 984          so force it not to be done.  */
 985       warn_inline = 0;
 986       flag_no_inline = 1;
 987     }
 988
 989   /* The optimization to partition hot and cold basic blocks into separate
 990      sections of the .o and executable files does not work (currently)
 991      with exception handling.  This is because there is no support for
 992      generating unwind info.  If flag_exceptions is turned on we need to
 993      turn off the partitioning optimization.  */
 994
 995   if (flag_exceptions && flag_reorder_blocks_and_partition
 996       && (USING_SJLJ_EXCEPTIONS
 997 #ifdef TARGET_UNWIND_INFO
 998           || 1
 999 #endif
1000          ))
1001     {
1002       inform (input_location,
1003               "-freorder-blocks-and-partition does not work with exceptions on this architecture");
1004       flag_reorder_blocks_and_partition = 0;
1005       flag_reorder_blocks = 1;
1006     }
1007
1008   /* If user requested unwind info, then turn off the partitioning
1009      optimization.  */
1010
1011   if (flag_unwind_tables && ! targetm.unwind_tables_default
1012       && flag_reorder_blocks_and_partition
1013       && (USING_SJLJ_EXCEPTIONS
1014 #ifdef TARGET_UNWIND_INFO
1015           || 1
1016 #endif
1017          ))
1018     {
1019       inform (input_location,
1020               "-freorder-blocks-and-partition does not support unwind info on this architecture");
1021       flag_reorder_blocks_and_partition = 0;
1022       flag_reorder_blocks = 1;
1023     }
1024
1025   /* If the target requested unwind info, then turn off the partitioning
1026      optimization with a different message.  Likewise, if the target does not
1027      support named sections.  */
1028
1029   if (flag_reorder_blocks_and_partition
1030       && (!targetm.have_named_sections
1031           || (flag_unwind_tables && targetm.unwind_tables_default
1032               && (USING_SJLJ_EXCEPTIONS
1033 #ifdef TARGET_UNWIND_INFO
1034                   || 1
1035 #endif
1036                  ))))
1037     {
1038       inform (input_location,
1039               "-freorder-blocks-and-partition does not work on this architecture");
1040       flag_reorder_blocks_and_partition = 0;
1041       flag_reorder_blocks = 1;
1042     }
1043
1044   /* Pipelining of outer loops is only possible when general pipelining
1045      capabilities are requested.  */
1046   if (!flag_sel_sched_pipelining)
1047     flag_sel_sched_pipelining_outer_loops = 0;
1048
1049   if (!targetm.ira_cover_classes
1050       && flag_ira_algorithm == IRA_ALGORITHM_CB)
1051     {
1052       inform (input_location,
1053               "-fira-algorithm=CB does not work on this architecture");
1054       flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1055     }
1056
1057   if (flag_conserve_stack)
1058     {
1059       if (!PARAM_SET_P (PARAM_LARGE_STACK_FRAME))
1060         PARAM_VALUE (PARAM_LARGE_STACK_FRAME) = 100;
1061       if (!PARAM_SET_P (PARAM_STACK_FRAME_GROWTH))
1062         PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) = 40;
1063     }
1064   if (flag_wpa || flag_ltrans)
1065     {
1066       /* These passes are not WHOPR compatible yet.  */
1067       flag_ipa_pta = 0;
1068       flag_ipa_struct_reorg = 0;
1069     }
1070
1071   if (flag_lto || flag_whopr)
1072     {
1073 #ifdef ENABLE_LTO
1074       flag_generate_lto = 1;
1075
1076       /* When generating IL, do not operate in whole-program mode.
1077          Otherwise, symbols will be privatized too early, causing link
1078          errors later.  */
1079       flag_whole_program = 0;
1080 #else
1081       error ("LTO support has not been enabled in this configuration");
1082 #endif
1083     }
1084
1085   /* Reconcile -flto and -fwhopr.  Set additional flags as appropriate and
1086      check option consistency.  */
1087   if (flag_lto && flag_whopr)
1088     error ("-flto and -fwhopr are mutually exclusive");
1089
1090   /* We initialize flag_split_stack to -1 so that targets can set a
1091      default value if they choose based on other options.  */
1092   if (flag_split_stack == -1)
1093     flag_split_stack = 0;
1094   else
1095     {
1096       if (!targetm.supports_split_stack (true))
1097         {
1098           error ("%<-fsplit-stack%> is not supported by "
1099                  "this compiler configuration");
1100           flag_split_stack = 0;
1101         }
1102     }
1103 }
1104
1105 #define LEFT_COLUMN     27
1106
1107 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1108    followed by word-wrapped HELP in a second column.  */
1109 static void
1110 wrap_help (const char *help,
1111            const char *item,
1112            unsigned int item_width,
1113            unsigned int columns)
1114 {
1115   unsigned int col_width = LEFT_COLUMN;
1116   unsigned int remaining, room, len;
1117
1118   remaining = strlen (help);
1119
1120   do
1121     {
1122       room = columns - 3 - MAX (col_width, item_width);
1123       if (room > columns)
1124         room = 0;
1125       len = remaining;
1126
1127       if (room < len)
1128         {
1129           unsigned int i;
1130
1131           for (i = 0; help[i]; i++)
1132             {
1133               if (i >= room && len != remaining)
1134                 break;
1135               if (help[i] == ' ')
1136                 len = i;
1137               else if ((help[i] == '-' || help[i] == '/')
1138                        && help[i + 1] != ' '
1139                        && i > 0 && ISALPHA (help[i - 1]))
1140                 len = i + 1;
1141             }
1142         }
1143
1144       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1145       item_width = 0;
1146       while (help[len] == ' ')
1147         len++;
1148       help += len;
1149       remaining -= len;
1150     }
1151   while (remaining);
1152 }
1153
1154 /* Print help for a specific front-end, etc.  */
1155 static void
1156 print_filtered_help (unsigned int include_flags,
1157                      unsigned int exclude_flags,
1158                      unsigned int any_flags,
1159                      unsigned int columns)
1160 {
1161   unsigned int i;
1162   const char *help;
1163   static char *printed = NULL;
1164   bool found = false;
1165   bool displayed = false;
1166
1167   if (include_flags == CL_PARAMS)
1168     {
1169       for (i = 0; i < LAST_PARAM; i++)
1170         {
1171           const char *param = compiler_params[i].option;
1172
1173           help = compiler_params[i].help;
1174           if (help == NULL || *help == '\0')
1175             {
1176               if (exclude_flags & CL_UNDOCUMENTED)
1177                 continue;
1178               help = undocumented_msg;
1179             }
1180
1181           /* Get the translation.  */
1182           help = _(help);
1183
1184           wrap_help (help, param, strlen (param), columns);
1185         }
1186       putchar ('\n');
1187       return;
1188     }
1189
1190   if (!printed)
1191     printed = XCNEWVAR (char, cl_options_count);
1192
1193   for (i = 0; i < cl_options_count; i++)
1194     {
1195       static char new_help[128];
1196       const struct cl_option *option = cl_options + i;
1197       unsigned int len;
1198       const char *opt;
1199       const char *tab;
1200
1201       if (include_flags == 0
1202           || ((option->flags & include_flags) != include_flags))
1203         {
1204           if ((option->flags & any_flags) == 0)
1205             continue;
1206         }
1207
1208       /* Skip unwanted switches.  */
1209       if ((option->flags & exclude_flags) != 0)
1210         continue;
1211
1212       /* The driver currently prints its own help text.  */
1213       if ((option->flags & CL_DRIVER) != 0
1214           && (option->flags & (((1U << cl_lang_count) - 1)
1215                                | CL_COMMON | CL_TARGET)) == 0)
1216         continue;
1217
1218       found = true;
1219       /* Skip switches that have already been printed.  */
1220       if (printed[i])
1221         continue;
1222
1223       printed[i] = true;
1224
1225       help = option->help;
1226       if (help == NULL)
1227         {
1228           if (exclude_flags & CL_UNDOCUMENTED)
1229             continue;
1230           help = undocumented_msg;
1231         }
1232
1233       /* Get the translation.  */
1234       help = _(help);
1235
1236       /* Find the gap between the name of the
1237          option and its descriptive text.  */
1238       tab = strchr (help, '\t');
1239       if (tab)
1240         {
1241           len = tab - help;
1242           opt = help;
1243           help = tab + 1;
1244         }
1245       else
1246         {
1247           opt = option->opt_text;
1248           len = strlen (opt);
1249         }
1250
1251       /* With the -Q option enabled we change the descriptive text associated
1252          with an option to be an indication of its current setting.  */
1253       if (!quiet_flag)
1254         {
1255           if (len < (LEFT_COLUMN + 2))
1256             strcpy (new_help, "\t\t");
1257           else
1258             strcpy (new_help, "\t");
1259
1260           if (option->flag_var != NULL)
1261             {
1262               if (option->flags & CL_JOINED)
1263                 {
1264                   if (option->var_type == CLVC_STRING)
1265                     {
1266                       if (* (const char **) option->flag_var != NULL)
1267                         snprintf (new_help + strlen (new_help),
1268                                   sizeof (new_help) - strlen (new_help),
1269                                   * (const char **) option->flag_var);
1270                     }
1271                   else
1272                     sprintf (new_help + strlen (new_help),
1273                              "%#x", * (int *) option->flag_var);
1274                 }
1275               else
1276                 strcat (new_help, option_enabled (i)
1277                         ? _("[enabled]") : _("[disabled]"));
1278             }
1279
1280           help = new_help;
1281         }
1282
1283       wrap_help (help, opt, len, columns);
1284       displayed = true;
1285     }
1286
1287   if (! found)
1288     {
1289       unsigned int langs = include_flags & CL_LANG_ALL;
1290
1291       if (langs == 0)
1292         printf (_(" No options with the desired characteristics were found\n"));
1293       else
1294         {
1295           unsigned int i;
1296
1297           /* PR 31349: Tell the user how to see all of the
1298              options supported by a specific front end.  */
1299           for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1300             if ((1U << i) & langs)
1301               printf (_(" None found.  Use --help=%s to show *all* the options supported by the %s front-end\n"),
1302                       lang_names[i], lang_names[i]);
1303         }
1304
1305     }
1306   else if (! displayed)
1307     printf (_(" All options with the desired characteristics have already been displayed\n"));
1308
1309   putchar ('\n');
1310 }
1311
1312 /* Display help for a specified type of option.
1313    The options must have ALL of the INCLUDE_FLAGS set
1314    ANY of the flags in the ANY_FLAGS set
1315    and NONE of the EXCLUDE_FLAGS set.  */
1316 static void
1317 print_specific_help (unsigned int include_flags,
1318                      unsigned int exclude_flags,
1319                      unsigned int any_flags)
1320 {
1321   unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1322   const char * description = NULL;
1323   const char * descrip_extra = "";
1324   size_t i;
1325   unsigned int flag;
1326   static unsigned int columns = 0;
1327
1328   /* Sanity check: Make sure that we do not have more
1329      languages than we have bits available to enumerate them.  */
1330   gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
1331
1332   /* If we have not done so already, obtain
1333      the desired maximum width of the output.  */
1334   if (columns == 0)
1335     {
1336       const char *p;
1337
1338       GET_ENVIRONMENT (p, "COLUMNS");
1339       if (p != NULL)
1340         {
1341           int value = atoi (p);
1342
1343           if (value > 0)
1344             columns = value;
1345         }
1346
1347       if (columns == 0)
1348         /* Use a reasonable default.  */
1349         columns = 80;
1350     }
1351
1352   /* Decide upon the title for the options that we are going to display.  */
1353   for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1354     {
1355       switch (flag & include_flags)
1356         {
1357         case 0:
1358         case CL_DRIVER:
1359           break;
1360
1361         case CL_TARGET:
1362           description = _("The following options are target specific");
1363           break;
1364         case CL_WARNING:
1365           description = _("The following options control compiler warning messages");
1366           break;
1367         case CL_OPTIMIZATION:
1368           description = _("The following options control optimizations");
1369           break;
1370         case CL_COMMON:
1371           description = _("The following options are language-independent");
1372           break;
1373         case CL_PARAMS:
1374           description = _("The --param option recognizes the following as parameters");
1375           break;
1376         default:
1377           if (i >= cl_lang_count)
1378             break;
1379           if (exclude_flags & all_langs_mask)
1380             description = _("The following options are specific to just the language ");
1381           else
1382             description = _("The following options are supported by the language ");
1383           descrip_extra = lang_names [i];
1384           break;
1385         }
1386     }
1387
1388   if (description == NULL)
1389     {
1390       if (any_flags == 0)
1391         {
1392           if (include_flags & CL_UNDOCUMENTED)
1393             description = _("The following options are not documented");
1394           else if (include_flags & CL_SEPARATE)
1395             description = _("The following options take separate arguments");
1396           else if (include_flags & CL_JOINED)
1397             description = _("The following options take joined arguments");
1398           else
1399             {
1400               internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1401                               include_flags);
1402               return;
1403             }
1404         }
1405       else
1406         {
1407           if (any_flags & all_langs_mask)
1408             description = _("The following options are language-related");
1409           else
1410             description = _("The following options are language-independent");
1411         }
1412     }
1413
1414   printf ("%s%s:\n", description, descrip_extra);
1415   print_filtered_help (include_flags, exclude_flags, any_flags, columns);
1416 }
1417
1418 /* Handle target- and language-independent options.  Return zero to
1419    generate an "unknown option" message.  Only options that need
1420    extra handling need to be listed here; if you simply want
1421    DECODED->value assigned to a variable, it happens automatically.  */
1422
1423 static bool
1424 common_handle_option (const struct cl_decoded_option *decoded,
1425                       unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
1426                       const struct cl_option_handlers *handlers)
1427 {
1428   size_t scode = decoded->opt_index;
1429   const char *arg = decoded->arg;
1430   int value = decoded->value;
1431   static bool verbose = false;
1432   enum opt_code code = (enum opt_code) scode;
1433
1434   gcc_assert (decoded->canonical_option_num_elements <= 2);
1435
1436   switch (code)
1437     {
1438     case OPT__param:
1439       handle_param (arg);
1440       break;
1441
1442     case OPT_v:
1443       verbose = true;
1444       break;
1445
1446     case OPT__help:
1447       {
1448         unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1449         unsigned int undoc_mask;
1450         unsigned int i;
1451
1452         undoc_mask = (verbose | extra_warnings) ? 0 : CL_UNDOCUMENTED;
1453         /* First display any single language specific options.  */
1454         for (i = 0; i < cl_lang_count; i++)
1455           print_specific_help
1456             (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0);
1457         /* Next display any multi language specific options.  */
1458         print_specific_help (0, undoc_mask, all_langs_mask);
1459         /* Then display any remaining, non-language options.  */
1460         for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1461           if (i != CL_DRIVER)
1462             print_specific_help (i, undoc_mask, 0);
1463         exit_after_options = true;
1464         break;
1465       }
1466
1467     case OPT__target_help:
1468       print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0);
1469       exit_after_options = true;
1470
1471       /* Allow the target a chance to give the user some additional information.  */
1472       if (targetm.help)
1473         targetm.help ();
1474       break;
1475
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__version:
1595       exit_after_options = true;
1596       break;
1597
1598     case OPT_O:
1599     case OPT_Os:
1600     case OPT_Ofast:
1601       /* Currently handled in a prescan.  */
1602       break;
1603
1604     case OPT_Werror_:
1605       enable_warning_as_error (arg, value, lang_mask, handlers);
1606       break;
1607
1608     case OPT_Wlarger_than_:
1609       larger_than_size = value;
1610       warn_larger_than = value != -1;
1611       break;
1612
1613     case OPT_Wfatal_errors:
1614       global_dc->fatal_errors = value;
1615       break;
1616
1617     case OPT_Wframe_larger_than_:
1618       frame_larger_than_size = value;
1619       warn_frame_larger_than = value != -1;
1620       break;
1621
1622     case OPT_Wstrict_aliasing:
1623       set_Wstrict_aliasing (value);
1624       break;
1625
1626     case OPT_Wstrict_aliasing_:
1627       warn_strict_aliasing = value;
1628       break;
1629
1630     case OPT_Wstrict_overflow:
1631       warn_strict_overflow = (value
1632                               ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1633                               : 0);
1634       break;
1635
1636     case OPT_Wstrict_overflow_:
1637       warn_strict_overflow = value;
1638       break;
1639
1640     case OPT_Wsystem_headers:
1641       global_dc->warn_system_headers = value;
1642       break;
1643
1644     case OPT_Wunused:
1645       warn_unused = value;
1646       break;
1647
1648     case OPT_aux_info:
1649       aux_info_file_name = arg;
1650       flag_gen_aux_info = 1;
1651       break;
1652
1653     case OPT_auxbase:
1654       aux_base_name = arg;
1655       break;
1656
1657     case OPT_auxbase_strip:
1658       {
1659         char *tmp = xstrdup (arg);
1660         strip_off_ending (tmp, strlen (tmp));
1661         if (tmp[0])
1662           aux_base_name = tmp;
1663       }
1664       break;
1665
1666     case OPT_d:
1667       decode_d_option (arg);
1668       break;
1669
1670     case OPT_dumpbase:
1671       dump_base_name = arg;
1672       break;
1673
1674     case OPT_dumpdir:
1675       dump_dir_name = arg;
1676       break;
1677
1678     case OPT_falign_functions_:
1679       align_functions = value;
1680       break;
1681
1682     case OPT_falign_jumps_:
1683       align_jumps = value;
1684       break;
1685
1686     case OPT_falign_labels_:
1687       align_labels = value;
1688       break;
1689
1690     case OPT_falign_loops_:
1691       align_loops = value;
1692       break;
1693
1694     case OPT_fbranch_probabilities:
1695       flag_branch_probabilities_set = true;
1696       break;
1697
1698     case OPT_fcall_used_:
1699       fix_register (arg, 0, 1);
1700       break;
1701
1702     case OPT_fcall_saved_:
1703       fix_register (arg, 0, 0);
1704       break;
1705
1706     case OPT_fdbg_cnt_:
1707       dbg_cnt_process_opt (arg);
1708       break;
1709
1710     case OPT_fdbg_cnt_list:
1711       dbg_cnt_list_all_counters ();
1712       break;
1713
1714     case OPT_fdebug_prefix_map_:
1715       add_debug_prefix_map (arg);
1716       break;
1717
1718     case OPT_fdiagnostics_show_location_:
1719       if (!strcmp (arg, "once"))
1720         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
1721       else if (!strcmp (arg, "every-line"))
1722         diagnostic_prefixing_rule (global_dc)
1723           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
1724       else
1725         return false;
1726       break;
1727
1728     case OPT_fdiagnostics_show_option:
1729       global_dc->show_option_requested = value;
1730       break;
1731
1732     case OPT_fdump_:
1733       if (!dump_switch_p (arg))
1734         return false;
1735       break;
1736
1737     case OPT_fexcess_precision_:
1738       if (!strcmp (arg, "fast"))
1739         flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
1740       else if (!strcmp (arg, "standard"))
1741         flag_excess_precision_cmdline = EXCESS_PRECISION_STANDARD;
1742       else
1743         error ("unknown excess precision style \"%s\"", arg);
1744       break;
1745
1746     case OPT_ffast_math:
1747       set_fast_math_flags (value);
1748       break;
1749
1750     case OPT_funsafe_math_optimizations:
1751       set_unsafe_math_optimizations_flags (value);
1752       break;
1753
1754     case OPT_ffixed_:
1755       fix_register (arg, 1, 1);
1756       break;
1757
1758     case OPT_finline_limit_:
1759       set_param_value ("max-inline-insns-single", value / 2);
1760       set_param_value ("max-inline-insns-auto", value / 2);
1761       break;
1762
1763     case OPT_finstrument_functions_exclude_function_list_:
1764       add_comma_separated_to_vector
1765         (&flag_instrument_functions_exclude_functions, arg);
1766       break;
1767
1768     case OPT_finstrument_functions_exclude_file_list_:
1769       add_comma_separated_to_vector
1770         (&flag_instrument_functions_exclude_files, arg);
1771       break;
1772
1773     case OPT_fmessage_length_:
1774       pp_set_line_maximum_length (global_dc->printer, value);
1775       break;
1776
1777     case OPT_fpack_struct_:
1778       if (value <= 0 || (value & (value - 1)) || value > 16)
1779         error ("structure alignment must be a small power of two, not %d", value);
1780       else
1781         {
1782           initial_max_fld_align = value;
1783           maximum_field_alignment = value * BITS_PER_UNIT;
1784         }
1785       break;
1786
1787     case OPT_fpeel_loops:
1788       flag_peel_loops_set = true;
1789       break;
1790
1791     case OPT_fplugin_:
1792 #ifdef ENABLE_PLUGIN
1793       add_new_plugin (arg);
1794 #else
1795       error ("Plugin support is disabled.  Configure with --enable-plugin.");
1796 #endif
1797       break;
1798
1799     case OPT_fplugin_arg_:
1800 #ifdef ENABLE_PLUGIN
1801       parse_plugin_arg_opt (arg);
1802 #else
1803       error ("Plugin support is disabled.  Configure with --enable-plugin.");
1804 #endif
1805       break;
1806
1807     case OPT_fprofile_arcs:
1808       profile_arc_flag_set = true;
1809       break;
1810
1811     case OPT_finline_functions:
1812       flag_inline_functions_set = true;
1813       break;
1814
1815     case OPT_fprofile_dir_:
1816       profile_data_prefix = xstrdup (arg);
1817       break;
1818
1819     case OPT_fprofile_use_:
1820       profile_data_prefix = xstrdup (arg);
1821       flag_profile_use = true;
1822       value = true;
1823       /* No break here - do -fprofile-use processing. */
1824     case OPT_fprofile_use:
1825       if (!flag_branch_probabilities_set)
1826         flag_branch_probabilities = value;
1827       if (!flag_profile_values_set)
1828         flag_profile_values = value;
1829       if (!flag_unroll_loops_set)
1830         flag_unroll_loops = value;
1831       if (!flag_peel_loops_set)
1832         flag_peel_loops = value;
1833       if (!flag_tracer_set)
1834         flag_tracer = value;
1835       if (!flag_value_profile_transformations_set)
1836         flag_value_profile_transformations = value;
1837       if (!flag_inline_functions_set)
1838         flag_inline_functions = value;
1839       if (!flag_ipa_cp_set)
1840         flag_ipa_cp = value;
1841       if (!flag_ipa_cp_clone_set
1842           && value && flag_ipa_cp)
1843         flag_ipa_cp_clone = value;
1844       if (!flag_predictive_commoning_set)
1845         flag_predictive_commoning = value;
1846       if (!flag_unswitch_loops_set)
1847         flag_unswitch_loops = value;
1848       if (!flag_gcse_after_reload_set)
1849         flag_gcse_after_reload = value;
1850       break;
1851
1852     case OPT_fprofile_generate_:
1853       profile_data_prefix = xstrdup (arg);
1854       value = true;
1855       /* No break here - do -fprofile-generate processing. */
1856     case OPT_fprofile_generate:
1857       if (!profile_arc_flag_set)
1858         profile_arc_flag = value;
1859       if (!flag_profile_values_set)
1860         flag_profile_values = value;
1861       if (!flag_value_profile_transformations_set)
1862         flag_value_profile_transformations = value;
1863       if (!flag_inline_functions_set)
1864         flag_inline_functions = value;
1865       break;
1866
1867     case OPT_fprofile_values:
1868       flag_profile_values_set = true;
1869       break;
1870
1871     case OPT_fshow_column:
1872       global_dc->show_column = value;
1873       break;
1874
1875     case OPT_fvisibility_:
1876       {
1877         if (!strcmp(arg, "default"))
1878           default_visibility = VISIBILITY_DEFAULT;
1879         else if (!strcmp(arg, "internal"))
1880           default_visibility = VISIBILITY_INTERNAL;
1881         else if (!strcmp(arg, "hidden"))
1882           default_visibility = VISIBILITY_HIDDEN;
1883         else if (!strcmp(arg, "protected"))
1884           default_visibility = VISIBILITY_PROTECTED;
1885         else
1886           error ("unrecognized visibility value \"%s\"", arg);
1887       }
1888       break;
1889
1890     case OPT_fvpt:
1891       flag_value_profile_transformations_set = true;
1892       break;
1893
1894     case OPT_frandom_seed:
1895       /* The real switch is -fno-random-seed.  */
1896       if (value)
1897         return false;
1898       set_random_seed (NULL);
1899       break;
1900
1901     case OPT_frandom_seed_:
1902       set_random_seed (arg);
1903       break;
1904
1905     case OPT_fselective_scheduling:
1906     case OPT_fselective_scheduling2:
1907       sel_sched_switch_set = true;
1908       break;
1909
1910     case OPT_fsched_verbose_:
1911 #ifdef INSN_SCHEDULING
1912       fix_sched_param ("verbose", arg);
1913       break;
1914 #else
1915       return false;
1916 #endif
1917
1918     case OPT_fsched_stalled_insns_:
1919       flag_sched_stalled_insns = value;
1920       if (flag_sched_stalled_insns == 0)
1921         flag_sched_stalled_insns = -1;
1922       break;
1923
1924     case OPT_fsched_stalled_insns_dep_:
1925       flag_sched_stalled_insns_dep = value;
1926       break;
1927
1928     case OPT_fstack_check_:
1929       if (!strcmp (arg, "no"))
1930         flag_stack_check = NO_STACK_CHECK;
1931       else if (!strcmp (arg, "generic"))
1932         /* This is the old stack checking method.  */
1933         flag_stack_check = STACK_CHECK_BUILTIN
1934                            ? FULL_BUILTIN_STACK_CHECK
1935                            : GENERIC_STACK_CHECK;
1936       else if (!strcmp (arg, "specific"))
1937         /* This is the new stack checking method.  */
1938         flag_stack_check = STACK_CHECK_BUILTIN
1939                            ? FULL_BUILTIN_STACK_CHECK
1940                            : STACK_CHECK_STATIC_BUILTIN
1941                              ? STATIC_BUILTIN_STACK_CHECK
1942                              : GENERIC_STACK_CHECK;
1943       else
1944         warning (0, "unknown stack check parameter \"%s\"", arg);
1945       break;
1946
1947     case OPT_fstack_limit:
1948       /* The real switch is -fno-stack-limit.  */
1949       if (value)
1950         return false;
1951       stack_limit_rtx = NULL_RTX;
1952       break;
1953
1954     case OPT_fstack_limit_register_:
1955       {
1956         int reg = decode_reg_name (arg);
1957         if (reg < 0)
1958           error ("unrecognized register name \"%s\"", arg);
1959         else
1960           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1961       }
1962       break;
1963
1964     case OPT_fstack_limit_symbol_:
1965       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1966       break;
1967
1968     case OPT_ftree_vectorizer_verbose_:
1969       vect_set_verbosity_level (arg);
1970       break;
1971
1972     case OPT_ftls_model_:
1973       if (!strcmp (arg, "global-dynamic"))
1974         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1975       else if (!strcmp (arg, "local-dynamic"))
1976         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1977       else if (!strcmp (arg, "initial-exec"))
1978         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1979       else if (!strcmp (arg, "local-exec"))
1980         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1981       else
1982         warning (0, "unknown tls-model \"%s\"", arg);
1983       break;
1984
1985     case OPT_fira_algorithm_:
1986       if (!strcmp (arg, "CB"))
1987         flag_ira_algorithm = IRA_ALGORITHM_CB;
1988       else if (!strcmp (arg, "priority"))
1989         flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1990       else
1991         warning (0, "unknown ira algorithm \"%s\"", arg);
1992       break;
1993
1994     case OPT_fira_region_:
1995       if (!strcmp (arg, "one"))
1996         flag_ira_region = IRA_REGION_ONE;
1997       else if (!strcmp (arg, "all"))
1998         flag_ira_region = IRA_REGION_ALL;
1999       else if (!strcmp (arg, "mixed"))
2000         flag_ira_region = IRA_REGION_MIXED;
2001       else
2002         warning (0, "unknown ira region \"%s\"", arg);
2003       break;
2004
2005     case OPT_fira_verbose_:
2006       flag_ira_verbose = value;
2007       break;
2008
2009     case OPT_ftracer:
2010       flag_tracer_set = true;
2011       break;
2012
2013     case OPT_fipa_cp:
2014       flag_ipa_cp_set = true;
2015       break;
2016
2017     case OPT_fipa_cp_clone:
2018       flag_ipa_cp_clone_set = true;
2019       break;
2020
2021     case OPT_fpredictive_commoning:
2022       flag_predictive_commoning_set = true;
2023       break;
2024
2025     case OPT_funswitch_loops:
2026       flag_unswitch_loops_set = true;
2027       break;
2028
2029     case OPT_fgcse_after_reload:
2030       flag_gcse_after_reload_set = true;
2031       break;
2032
2033     case OPT_funroll_loops:
2034       flag_unroll_loops_set = true;
2035       break;
2036
2037     case OPT_g:
2038       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
2039       break;
2040
2041     case OPT_gcoff:
2042       set_debug_level (SDB_DEBUG, false, arg);
2043       break;
2044
2045     case OPT_gdwarf_:
2046       if (value < 2 || value > 4)
2047         error ("dwarf version %d is not supported", value);
2048       else
2049         dwarf_version = value;
2050       set_debug_level (DWARF2_DEBUG, false, "");
2051       break;
2052
2053     case OPT_ggdb:
2054       set_debug_level (NO_DEBUG, 2, arg);
2055       break;
2056
2057     case OPT_gstabs:
2058     case OPT_gstabs_:
2059       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
2060       break;
2061
2062     case OPT_gvms:
2063       set_debug_level (VMS_DEBUG, false, arg);
2064       break;
2065
2066     case OPT_gxcoff:
2067     case OPT_gxcoff_:
2068       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
2069       break;
2070
2071     case OPT_o:
2072       asm_file_name = arg;
2073       break;
2074
2075     case OPT_pedantic_errors:
2076       flag_pedantic_errors = pedantic = 1;
2077       global_dc->pedantic_errors = 1;
2078       break;
2079
2080     case OPT_fwhopr_:
2081       flag_whopr = arg;
2082       break;
2083
2084     case OPT_fwhopr:
2085       flag_whopr = "";
2086       break;
2087
2088     case OPT_w:
2089       global_dc->inhibit_warnings = true;
2090       break;
2091
2092     case OPT_fuse_linker_plugin:
2093       /* No-op. Used by the driver and passed to us because it starts with f.*/
2094       break;
2095
2096     default:
2097       /* If the flag was handled in a standard way, assume the lack of
2098          processing here is intentional.  */
2099       gcc_assert (cl_options[scode].flag_var);
2100       break;
2101     }
2102
2103   return true;
2104 }
2105
2106 /* Handle --param NAME=VALUE.  */
2107 static void
2108 handle_param (const char *carg)
2109 {
2110   char *equal, *arg;
2111   int value;
2112
2113   arg = xstrdup (carg);
2114   equal = strchr (arg, '=');
2115   if (!equal)
2116     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
2117   else
2118     {
2119       value = integral_argument (equal + 1);
2120       if (value == -1)
2121         error ("invalid --param value %qs", equal + 1);
2122       else
2123         {
2124           *equal = '\0';
2125           set_param_value (arg, value);
2126         }
2127     }
2128
2129   free (arg);
2130 }
2131
2132 /* Used to set the level of strict aliasing warnings,
2133    when no level is specified (i.e., when -Wstrict-aliasing, and not
2134    -Wstrict-aliasing=level was given).
2135    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2136    and 0 otherwise.  After calling this function, wstrict_aliasing will be
2137    set to the default value of -Wstrict_aliasing=level, currently 3.  */
2138 void
2139 set_Wstrict_aliasing (int onoff)
2140 {
2141   gcc_assert (onoff == 0 || onoff == 1);
2142   if (onoff != 0)
2143     warn_strict_aliasing = 3;
2144   else
2145     warn_strict_aliasing = 0;
2146 }
2147
2148 /* The following routines are useful in setting all the flags that
2149    -ffast-math and -fno-fast-math imply.  */
2150 void
2151 set_fast_math_flags (int set)
2152 {
2153   flag_unsafe_math_optimizations = set;
2154   set_unsafe_math_optimizations_flags (set);
2155   flag_finite_math_only = set;
2156   flag_errno_math = !set;
2157   if (set)
2158     {
2159       flag_signaling_nans = 0;
2160       flag_rounding_math = 0;
2161       flag_cx_limited_range = 1;
2162     }
2163 }
2164
2165 /* When -funsafe-math-optimizations is set the following
2166    flags are set as well.  */
2167 void
2168 set_unsafe_math_optimizations_flags (int set)
2169 {
2170   flag_trapping_math = !set;
2171   flag_signed_zeros = !set;
2172   flag_associative_math = set;
2173   flag_reciprocal_math = set;
2174 }
2175
2176 /* Return true iff flags are set as if -ffast-math.  */
2177 bool
2178 fast_math_flags_set_p (void)
2179 {
2180   return (!flag_trapping_math
2181           && flag_unsafe_math_optimizations
2182           && flag_finite_math_only
2183           && !flag_signed_zeros
2184           && !flag_errno_math);
2185 }
2186
2187 /* Return true iff flags are set as if -ffast-math but using the flags stored
2188    in the struct cl_optimization structure.  */
2189 bool
2190 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2191 {
2192   return (!opt->flag_trapping_math
2193           && opt->flag_unsafe_math_optimizations
2194           && opt->flag_finite_math_only
2195           && !opt->flag_signed_zeros
2196           && !opt->flag_errno_math);
2197 }
2198
2199 /* Handle a debug output -g switch.  EXTENDED is true or false to support
2200    extended output (2 is special and means "-ggdb" was given).  */
2201 static void
2202 set_debug_level (enum debug_info_type type, int extended, const char *arg)
2203 {
2204   static bool type_explicit;
2205
2206   use_gnu_debug_info_extensions = extended;
2207
2208   if (type == NO_DEBUG)
2209     {
2210       if (write_symbols == NO_DEBUG)
2211         {
2212           write_symbols = PREFERRED_DEBUGGING_TYPE;
2213
2214           if (extended == 2)
2215             {
2216 #ifdef DWARF2_DEBUGGING_INFO
2217               write_symbols = DWARF2_DEBUG;
2218 #elif defined DBX_DEBUGGING_INFO
2219               write_symbols = DBX_DEBUG;
2220 #endif
2221             }
2222
2223           if (write_symbols == NO_DEBUG)
2224             warning (0, "target system does not support debug output");
2225         }
2226     }
2227   else
2228     {
2229       /* Does it conflict with an already selected type?  */
2230       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
2231         error ("debug format \"%s\" conflicts with prior selection",
2232                debug_type_names[type]);
2233       write_symbols = type;
2234       type_explicit = true;
2235     }
2236
2237   /* A debug flag without a level defaults to level 2.  */
2238   if (*arg == '\0')
2239     {
2240       if (!debug_info_level)
2241         debug_info_level = DINFO_LEVEL_NORMAL;
2242     }
2243   else
2244     {
2245       int argval = integral_argument (arg);
2246       if (argval == -1)
2247         error ("unrecognised debug output level \"%s\"", arg);
2248       else if (argval > 3)
2249         error ("debug output level %s is too high", arg);
2250       else
2251         debug_info_level = (enum debug_info_level) argval;
2252     }
2253 }
2254
2255 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
2256    a simple on-off switch.  */
2257
2258 int
2259 option_enabled (int opt_idx)
2260 {
2261   const struct cl_option *option = &(cl_options[opt_idx]);
2262
2263   if (option->flag_var)
2264     switch (option->var_type)
2265       {
2266       case CLVC_BOOLEAN:
2267         return *(int *) option->flag_var != 0;
2268
2269       case CLVC_EQUAL:
2270         return *(int *) option->flag_var == option->var_value;
2271
2272       case CLVC_BIT_CLEAR:
2273         return (*(int *) option->flag_var & option->var_value) == 0;
2274
2275       case CLVC_BIT_SET:
2276         return (*(int *) option->flag_var & option->var_value) != 0;
2277
2278       case CLVC_STRING:
2279         break;
2280       }
2281   return -1;
2282 }
2283
2284 /* Fill STATE with the current state of option OPTION.  Return true if
2285    there is some state to store.  */
2286
2287 bool
2288 get_option_state (int option, struct cl_option_state *state)
2289 {
2290   if (cl_options[option].flag_var == 0)
2291     return false;
2292
2293   switch (cl_options[option].var_type)
2294     {
2295     case CLVC_BOOLEAN:
2296     case CLVC_EQUAL:
2297       state->data = cl_options[option].flag_var;
2298       state->size = sizeof (int);
2299       break;
2300
2301     case CLVC_BIT_CLEAR:
2302     case CLVC_BIT_SET:
2303       state->ch = option_enabled (option);
2304       state->data = &state->ch;
2305       state->size = 1;
2306       break;
2307
2308     case CLVC_STRING:
2309       state->data = *(const char **) cl_options[option].flag_var;
2310       if (state->data == 0)
2311         state->data = "";
2312       state->size = strlen ((const char *) state->data) + 1;
2313       break;
2314     }
2315   return true;
2316 }
2317
2318 /* Callback function, called when -Werror= enables a warning.  */
2319
2320 static void (*warning_as_error_callback) (int) = NULL;
2321
2322 /* Register a callback for enable_warning_as_error calls.  */
2323
2324 void
2325 register_warning_as_error_callback (void (*callback) (int))
2326 {
2327   gcc_assert (warning_as_error_callback == NULL || callback == NULL);
2328   warning_as_error_callback = callback;
2329 }
2330
2331 /* Enable a warning option as an error.  This is used by -Werror= and
2332    also by legacy Werror-implicit-function-declaration.  */
2333
2334 void
2335 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
2336                          const struct cl_option_handlers *handlers)
2337 {
2338   char *new_option;
2339   int option_index;
2340
2341   new_option = XNEWVEC (char, strlen (arg) + 2);
2342   new_option[0] = 'W';
2343   strcpy (new_option + 1, arg);
2344   option_index = find_opt (new_option, lang_mask);
2345   if (option_index == OPT_SPECIAL_unknown)
2346     {
2347       error ("-Werror=%s: No option -%s", arg, new_option);
2348     }
2349   else
2350     {
2351       const struct cl_option *option = &cl_options[option_index];
2352       const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
2353
2354       if (option->alias_target != N_OPTS)
2355         option_index = option->alias_target;
2356       if (option_index == OPT_SPECIAL_ignore)
2357         return;
2358       diagnostic_classify_diagnostic (global_dc, option_index, kind,
2359                                       UNKNOWN_LOCATION);
2360       if (kind == DK_ERROR)
2361         {
2362           const struct cl_option * const option = cl_options + option_index;
2363
2364           /* -Werror=foo implies -Wfoo.  */
2365           if (option->var_type == CLVC_BOOLEAN)
2366             handle_generated_option (option_index, NULL, value, lang_mask,
2367                                      (int)kind, handlers);
2368
2369           if (warning_as_error_callback)
2370             warning_as_error_callback (option_index);
2371         }
2372     }
2373   free (new_option);
2374 }
2375
2376 /* Return malloced memory for the name of the option OPTION_INDEX
2377    which enabled a diagnostic (context CONTEXT), originally of type
2378    ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2379    as -Werror.  */
2380
2381 char *
2382 option_name (diagnostic_context *context, int option_index,
2383              diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
2384 {
2385   if (option_index)
2386     {
2387       /* A warning classified as an error.  */
2388       if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
2389           && diag_kind == DK_ERROR)
2390         return concat (cl_options[OPT_Werror_].opt_text,
2391                        /* Skip over "-W".  */
2392                        cl_options[option_index].opt_text + 2,
2393                        NULL);
2394       /* A warning with option.  */
2395       else
2396         return xstrdup (cl_options[option_index].opt_text);
2397     }
2398   /* A warning without option classified as an error.  */
2399   else if (orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
2400            || diag_kind == DK_WARNING)
2401     {
2402       if (context->warning_as_error_requested)
2403         return xstrdup (cl_options[OPT_Werror].opt_text);
2404       else
2405         return xstrdup (_("enabled by default"));
2406     }
2407   else
2408     return NULL;
2409 }