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