gcc/opts.c

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