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