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