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     = compiler_params[PARAM_MIN_CROSSJUMP_INSNS].value;
 673   initial_max_fields_for_field_sensitive
 674     = compiler_params[PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE].value;
 675   initial_loop_invariant_max_bbs_in_loop
 676     = compiler_params[PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP].value;
 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   set_param_value ("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   set_param_value ("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       set_param_value ("min-crossjump-insns", 1);
 895     }
 896   else
 897     set_param_value ("min-crossjump-insns", initial_min_crossjump_insns);
 898
 899   /* -Ofast adds optimizations to -O3.  */
 900   if (ofast)
 901     {
 902       /* Which is -ffast-math for now.  */
 903       set_fast_math_flags (1);
 904       /* Allow targets to enable extra options with -Ofast
 905          before general options processing so disabling them
 906          again afterwards works.  */
 907       targetm.handle_ofast ();
 908     }
 909
 910   /* Allow default optimizations to be specified on a per-machine basis.  */
 911   targetm.target_option.optimization (optimize, optimize_size);
 912 }
 913
 914 static void finish_options (struct gcc_options *, struct gcc_options *);
 915
 916 /* Parse command line options and set default flag values.  Do minimal
 917    options processing.  The decoded options are in *DECODED_OPTIONS
 918    and *DECODED_OPTIONS_COUNT.  */
 919 void
 920 decode_options (struct gcc_options *opts, struct gcc_options *opts_set,
 921                 struct cl_decoded_option *decoded_options,
 922                 unsigned int decoded_options_count)
 923 {
 924   struct cl_option_handlers handlers;
 925
 926   unsigned int lang_mask;
 927
 928   lang_mask = initial_lang_mask;
 929
 930   handlers.unknown_option_callback = unknown_option_callback;
 931   handlers.wrong_lang_callback = complain_wrong_lang;
 932   handlers.post_handling_callback = post_handling_callback;
 933   handlers.num_handlers = 3;
 934   handlers.handlers[0].handler = lang_handle_option;
 935   handlers.handlers[0].mask = lang_mask;
 936   handlers.handlers[1].handler = common_handle_option;
 937   handlers.handlers[1].mask = CL_COMMON;
 938   handlers.handlers[2].handler = target_handle_option;
 939   handlers.handlers[2].mask = CL_TARGET;
 940
 941   /* Enable -Werror=coverage-mismatch by default */
 942   enable_warning_as_error ("coverage-mismatch", 1, lang_mask, &handlers,
 943                            global_dc);
 944
 945   default_options_optimization (opts, opts_set,
 946                                 decoded_options, decoded_options_count);
 947
 948 #ifdef ENABLE_LTO
 949   /* Clear any options currently held for LTO.  */
 950   lto_clear_user_options ();
 951 #endif
 952
 953   read_cmdline_options (opts, opts_set,
 954                         decoded_options, decoded_options_count, lang_mask,
 955                         &handlers);
 956
 957   finish_options (opts, opts_set);
 958 }
 959
 960 /* After all options have been read into OPTS and OPTS_SET, finalize
 961    settings of those options and diagnose incompatible
 962    combinations.  */
 963 static void
 964 finish_options (struct gcc_options *opts, struct gcc_options *opts_set)
 965 {
 966   static bool first_time_p = true;
 967   enum unwind_info_type ui_except;
 968
 969   gcc_assert (opts == &global_options);
 970   gcc_assert (opts_set = &global_options_set);
 971
 972   if (dump_base_name && ! IS_ABSOLUTE_PATH (dump_base_name))
 973     {
 974       /* First try to make DUMP_BASE_NAME relative to the DUMP_DIR_NAME
 975          directory.  Then try to make DUMP_BASE_NAME relative to the
 976          AUX_BASE_NAME directory, typically the directory to contain
 977          the object file.  */
 978       if (dump_dir_name)
 979         dump_base_name = concat (dump_dir_name, dump_base_name, NULL);
 980       else if (aux_base_name)
 981         {
 982           const char *aux_base;
 983
 984           base_of_path (aux_base_name, &aux_base);
 985           if (aux_base_name != aux_base)
 986             {
 987               int dir_len = aux_base - aux_base_name;
 988               char *new_dump_base_name =
 989                 XNEWVEC (char, strlen(dump_base_name) + dir_len + 1);
 990
 991               /* Copy directory component from AUX_BASE_NAME.  */
 992               memcpy (new_dump_base_name, aux_base_name, dir_len);
 993               /* Append existing DUMP_BASE_NAME.  */
 994               strcpy (new_dump_base_name + dir_len, dump_base_name);
 995               dump_base_name = new_dump_base_name;
 996             }
 997         }
 998     }
 999
1000   /* Handle related options for unit-at-a-time, toplevel-reorder, and
1001      section-anchors.  */
1002   if (!flag_unit_at_a_time)
1003     {
1004       if (flag_section_anchors == 1)
1005         error ("Section anchors must be disabled when unit-at-a-time "
1006                "is disabled.");
1007       flag_section_anchors = 0;
1008       if (flag_toplevel_reorder == 1)
1009         error ("Toplevel reorder must be disabled when unit-at-a-time "
1010                "is disabled.");
1011       flag_toplevel_reorder = 0;
1012     }
1013
1014   /* -Wmissing-noreturn is alias for -Wsuggest-attribute=noreturn.  */
1015   if (warn_missing_noreturn)
1016     warn_suggest_attribute_noreturn = true;
1017
1018   /* Unless the user has asked for section anchors, we disable toplevel
1019      reordering at -O0 to disable transformations that might be surprising
1020      to end users and to get -fno-toplevel-reorder tested.  */
1021   if (!optimize && flag_toplevel_reorder == 2 && flag_section_anchors != 1)
1022     {
1023       flag_toplevel_reorder = 0;
1024       flag_section_anchors = 0;
1025     }
1026   if (!flag_toplevel_reorder)
1027     {
1028       if (flag_section_anchors == 1)
1029         error ("section anchors must be disabled when toplevel reorder"
1030                " is disabled");
1031       flag_section_anchors = 0;
1032     }
1033
1034   if (first_time_p)
1035     {
1036       if (flag_pie)
1037         flag_pic = flag_pie;
1038       if (flag_pic && !flag_pie)
1039         flag_shlib = 1;
1040       first_time_p = false;
1041     }
1042
1043   if (optimize == 0)
1044     {
1045       /* Inlining does not work if not optimizing,
1046          so force it not to be done.  */
1047       warn_inline = 0;
1048       flag_no_inline = 1;
1049     }
1050
1051   /* The optimization to partition hot and cold basic blocks into separate
1052      sections of the .o and executable files does not work (currently)
1053      with exception handling.  This is because there is no support for
1054      generating unwind info.  If flag_exceptions is turned on we need to
1055      turn off the partitioning optimization.  */
1056
1057   ui_except = targetm.except_unwind_info ();
1058
1059   if (flag_exceptions
1060       && flag_reorder_blocks_and_partition
1061       && (ui_except == UI_SJLJ || ui_except == UI_TARGET))
1062     {
1063       inform (input_location,
1064               "-freorder-blocks-and-partition does not work "
1065               "with exceptions on this architecture");
1066       flag_reorder_blocks_and_partition = 0;
1067       flag_reorder_blocks = 1;
1068     }
1069
1070   /* If user requested unwind info, then turn off the partitioning
1071      optimization.  */
1072
1073   if (flag_unwind_tables
1074       && !targetm.unwind_tables_default
1075       && flag_reorder_blocks_and_partition
1076       && (ui_except == UI_SJLJ || ui_except == UI_TARGET))
1077     {
1078       inform (input_location,
1079               "-freorder-blocks-and-partition does not support "
1080               "unwind info on this architecture");
1081       flag_reorder_blocks_and_partition = 0;
1082       flag_reorder_blocks = 1;
1083     }
1084
1085   /* If the target requested unwind info, then turn off the partitioning
1086      optimization with a different message.  Likewise, if the target does not
1087      support named sections.  */
1088
1089   if (flag_reorder_blocks_and_partition
1090       && (!targetm.have_named_sections
1091           || (flag_unwind_tables
1092               && targetm.unwind_tables_default
1093               && (ui_except == UI_SJLJ || ui_except == UI_TARGET))))
1094     {
1095       inform (input_location,
1096               "-freorder-blocks-and-partition does not work "
1097               "on this architecture");
1098       flag_reorder_blocks_and_partition = 0;
1099       flag_reorder_blocks = 1;
1100     }
1101
1102   /* Pipelining of outer loops is only possible when general pipelining
1103      capabilities are requested.  */
1104   if (!flag_sel_sched_pipelining)
1105     flag_sel_sched_pipelining_outer_loops = 0;
1106
1107   if (!targetm.ira_cover_classes
1108       && flag_ira_algorithm == IRA_ALGORITHM_CB)
1109     {
1110       inform (input_location,
1111               "-fira-algorithm=CB does not work on this architecture");
1112       flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1113     }
1114
1115   if (flag_conserve_stack)
1116     {
1117       if (!PARAM_SET_P (PARAM_LARGE_STACK_FRAME))
1118         PARAM_VALUE (PARAM_LARGE_STACK_FRAME) = 100;
1119       if (!PARAM_SET_P (PARAM_STACK_FRAME_GROWTH))
1120         PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) = 40;
1121     }
1122   if (flag_wpa || flag_ltrans)
1123     {
1124       /* These passes are not WHOPR compatible yet.  */
1125       flag_ipa_pta = 0;
1126       flag_ipa_struct_reorg = 0;
1127     }
1128
1129   if (flag_lto || flag_whopr)
1130     {
1131 #ifdef ENABLE_LTO
1132       flag_generate_lto = 1;
1133
1134       /* When generating IL, do not operate in whole-program mode.
1135          Otherwise, symbols will be privatized too early, causing link
1136          errors later.  */
1137       flag_whole_program = 0;
1138 #else
1139       error ("LTO support has not been enabled in this configuration");
1140 #endif
1141     }
1142   if (flag_lto_partition_balanced || flag_lto_partition_1to1)
1143     {
1144       if (flag_lto_partition_balanced && flag_lto_partition_1to1)
1145         error ("Only one -flto-partitoin value can be specified");
1146       if (!flag_whopr)
1147         error ("-flto-partitoin has effect only with -fwhopr");
1148     }
1149
1150   /* Reconcile -flto and -fwhopr.  Set additional flags as appropriate and
1151      check option consistency.  */
1152   if (flag_lto && flag_whopr)
1153     error ("-flto and -fwhopr are mutually exclusive");
1154
1155   /* We initialize flag_split_stack to -1 so that targets can set a
1156      default value if they choose based on other options.  */
1157   if (flag_split_stack == -1)
1158     flag_split_stack = 0;
1159   else if (flag_split_stack)
1160     {
1161       if (!targetm.supports_split_stack (true))
1162         {
1163           error ("%<-fsplit-stack%> is not supported by "
1164                  "this compiler configuration");
1165           flag_split_stack = 0;
1166         }
1167     }
1168 }
1169
1170 #define LEFT_COLUMN     27
1171
1172 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1173    followed by word-wrapped HELP in a second column.  */
1174 static void
1175 wrap_help (const char *help,
1176            const char *item,
1177            unsigned int item_width,
1178            unsigned int columns)
1179 {
1180   unsigned int col_width = LEFT_COLUMN;
1181   unsigned int remaining, room, len;
1182
1183   remaining = strlen (help);
1184
1185   do
1186     {
1187       room = columns - 3 - MAX (col_width, item_width);
1188       if (room > columns)
1189         room = 0;
1190       len = remaining;
1191
1192       if (room < len)
1193         {
1194           unsigned int i;
1195
1196           for (i = 0; help[i]; i++)
1197             {
1198               if (i >= room && len != remaining)
1199                 break;
1200               if (help[i] == ' ')
1201                 len = i;
1202               else if ((help[i] == '-' || help[i] == '/')
1203                        && help[i + 1] != ' '
1204                        && i > 0 && ISALPHA (help[i - 1]))
1205                 len = i + 1;
1206             }
1207         }
1208
1209       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1210       item_width = 0;
1211       while (help[len] == ' ')
1212         len++;
1213       help += len;
1214       remaining -= len;
1215     }
1216   while (remaining);
1217 }
1218
1219 /* Print help for a specific front-end, etc.  */
1220 static void
1221 print_filtered_help (unsigned int include_flags,
1222                      unsigned int exclude_flags,
1223                      unsigned int any_flags,
1224                      unsigned int columns)
1225 {
1226   unsigned int i;
1227   const char *help;
1228   static char *printed = NULL;
1229   bool found = false;
1230   bool displayed = false;
1231
1232   if (include_flags == CL_PARAMS)
1233     {
1234       for (i = 0; i < LAST_PARAM; i++)
1235         {
1236           const char *param = compiler_params[i].option;
1237
1238           help = compiler_params[i].help;
1239           if (help == NULL || *help == '\0')
1240             {
1241               if (exclude_flags & CL_UNDOCUMENTED)
1242                 continue;
1243               help = undocumented_msg;
1244             }
1245
1246           /* Get the translation.  */
1247           help = _(help);
1248
1249           wrap_help (help, param, strlen (param), columns);
1250         }
1251       putchar ('\n');
1252       return;
1253     }
1254
1255   if (!printed)
1256     printed = XCNEWVAR (char, cl_options_count);
1257
1258   for (i = 0; i < cl_options_count; i++)
1259     {
1260       static char new_help[128];
1261       const struct cl_option *option = cl_options + i;
1262       unsigned int len;
1263       const char *opt;
1264       const char *tab;
1265
1266       if (include_flags == 0
1267           || ((option->flags & include_flags) != include_flags))
1268         {
1269           if ((option->flags & any_flags) == 0)
1270             continue;
1271         }
1272
1273       /* Skip unwanted switches.  */
1274       if ((option->flags & exclude_flags) != 0)
1275         continue;
1276
1277       /* The driver currently prints its own help text.  */
1278       if ((option->flags & CL_DRIVER) != 0
1279           && (option->flags & (((1U << cl_lang_count) - 1)
1280                                | CL_COMMON | CL_TARGET)) == 0)
1281         continue;
1282
1283       found = true;
1284       /* Skip switches that have already been printed.  */
1285       if (printed[i])
1286         continue;
1287
1288       printed[i] = true;
1289
1290       help = option->help;
1291       if (help == NULL)
1292         {
1293           if (exclude_flags & CL_UNDOCUMENTED)
1294             continue;
1295           help = undocumented_msg;
1296         }
1297
1298       /* Get the translation.  */
1299       help = _(help);
1300
1301       /* Find the gap between the name of the
1302          option and its descriptive text.  */
1303       tab = strchr (help, '\t');
1304       if (tab)
1305         {
1306           len = tab - help;
1307           opt = help;
1308           help = tab + 1;
1309         }
1310       else
1311         {
1312           opt = option->opt_text;
1313           len = strlen (opt);
1314         }
1315
1316       /* With the -Q option enabled we change the descriptive text associated
1317          with an option to be an indication of its current setting.  */
1318       if (!quiet_flag)
1319         {
1320           void *flag_var = option_flag_var (i, &global_options);
1321
1322           if (len < (LEFT_COLUMN + 2))
1323             strcpy (new_help, "\t\t");
1324           else
1325             strcpy (new_help, "\t");
1326
1327           if (flag_var != NULL)
1328             {
1329               if (option->flags & CL_JOINED)
1330                 {
1331                   if (option->var_type == CLVC_STRING)
1332                     {
1333                       if (* (const char **) flag_var != NULL)
1334                         snprintf (new_help + strlen (new_help),
1335                                   sizeof (new_help) - strlen (new_help),
1336                                   * (const char **) flag_var);
1337                     }
1338                   else
1339                     sprintf (new_help + strlen (new_help),
1340                              "%#x", * (int *) flag_var);
1341                 }
1342               else
1343                 strcat (new_help, option_enabled (i, &global_options)
1344                         ? _("[enabled]") : _("[disabled]"));
1345             }
1346
1347           help = new_help;
1348         }
1349
1350       wrap_help (help, opt, len, columns);
1351       displayed = true;
1352     }
1353
1354   if (! found)
1355     {
1356       unsigned int langs = include_flags & CL_LANG_ALL;
1357
1358       if (langs == 0)
1359         printf (_(" No options with the desired characteristics were found\n"));
1360       else
1361         {
1362           unsigned int i;
1363
1364           /* PR 31349: Tell the user how to see all of the
1365              options supported by a specific front end.  */
1366           for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1367             if ((1U << i) & langs)
1368               printf (_(" None found.  Use --help=%s to show *all* the options supported by the %s front-end\n"),
1369                       lang_names[i], lang_names[i]);
1370         }
1371
1372     }
1373   else if (! displayed)
1374     printf (_(" All options with the desired characteristics have already been displayed\n"));
1375
1376   putchar ('\n');
1377 }
1378
1379 /* Display help for a specified type of option.
1380    The options must have ALL of the INCLUDE_FLAGS set
1381    ANY of the flags in the ANY_FLAGS set
1382    and NONE of the EXCLUDE_FLAGS set.  */
1383 static void
1384 print_specific_help (unsigned int include_flags,
1385                      unsigned int exclude_flags,
1386                      unsigned int any_flags)
1387 {
1388   unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1389   const char * description = NULL;
1390   const char * descrip_extra = "";
1391   size_t i;
1392   unsigned int flag;
1393   static unsigned int columns = 0;
1394
1395   /* Sanity check: Make sure that we do not have more
1396      languages than we have bits available to enumerate them.  */
1397   gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
1398
1399   /* If we have not done so already, obtain
1400      the desired maximum width of the output.  */
1401   if (columns == 0)
1402     {
1403       const char *p;
1404
1405       GET_ENVIRONMENT (p, "COLUMNS");
1406       if (p != NULL)
1407         {
1408           int value = atoi (p);
1409
1410           if (value > 0)
1411             columns = value;
1412         }
1413
1414       if (columns == 0)
1415         /* Use a reasonable default.  */
1416         columns = 80;
1417     }
1418
1419   /* Decide upon the title for the options that we are going to display.  */
1420   for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1421     {
1422       switch (flag & include_flags)
1423         {
1424         case 0:
1425         case CL_DRIVER:
1426           break;
1427
1428         case CL_TARGET:
1429           description = _("The following options are target specific");
1430           break;
1431         case CL_WARNING:
1432           description = _("The following options control compiler warning messages");
1433           break;
1434         case CL_OPTIMIZATION:
1435           description = _("The following options control optimizations");
1436           break;
1437         case CL_COMMON:
1438           description = _("The following options are language-independent");
1439           break;
1440         case CL_PARAMS:
1441           description = _("The --param option recognizes the following as parameters");
1442           break;
1443         default:
1444           if (i >= cl_lang_count)
1445             break;
1446           if (exclude_flags & all_langs_mask)
1447             description = _("The following options are specific to just the language ");
1448           else
1449             description = _("The following options are supported by the language ");
1450           descrip_extra = lang_names [i];
1451           break;
1452         }
1453     }
1454
1455   if (description == NULL)
1456     {
1457       if (any_flags == 0)
1458         {
1459           if (include_flags & CL_UNDOCUMENTED)
1460             description = _("The following options are not documented");
1461           else if (include_flags & CL_SEPARATE)
1462             description = _("The following options take separate arguments");
1463           else if (include_flags & CL_JOINED)
1464             description = _("The following options take joined arguments");
1465           else
1466             {
1467               internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1468                               include_flags);
1469               return;
1470             }
1471         }
1472       else
1473         {
1474           if (any_flags & all_langs_mask)
1475             description = _("The following options are language-related");
1476           else
1477             description = _("The following options are language-independent");
1478         }
1479     }
1480
1481   printf ("%s%s:\n", description, descrip_extra);
1482   print_filtered_help (include_flags, exclude_flags, any_flags, columns);
1483 }
1484
1485 /* Handle target- and language-independent options.  Return zero to
1486    generate an "unknown option" message.  Only options that need
1487    extra handling need to be listed here; if you simply want
1488    DECODED->value assigned to a variable, it happens automatically.  */
1489
1490 static bool
1491 common_handle_option (struct gcc_options *opts,
1492                       struct gcc_options *opts_set,
1493                       const struct cl_decoded_option *decoded,
1494                       unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
1495                       const struct cl_option_handlers *handlers)
1496 {
1497   size_t scode = decoded->opt_index;
1498   const char *arg = decoded->arg;
1499   int value = decoded->value;
1500   static bool verbose = false;
1501   enum opt_code code = (enum opt_code) scode;
1502
1503   gcc_assert (opts == &global_options);
1504   gcc_assert (opts_set == &global_options_set);
1505   gcc_assert (decoded->canonical_option_num_elements <= 2);
1506
1507   switch (code)
1508     {
1509     case OPT__param:
1510       handle_param (arg);
1511       break;
1512
1513     case OPT_v:
1514       verbose = true;
1515       break;
1516
1517     case OPT__help:
1518       {
1519         unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1520         unsigned int undoc_mask;
1521         unsigned int i;
1522
1523         undoc_mask = (verbose | extra_warnings) ? 0 : CL_UNDOCUMENTED;
1524         /* First display any single language specific options.  */
1525         for (i = 0; i < cl_lang_count; i++)
1526           print_specific_help
1527             (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0);
1528         /* Next display any multi language specific options.  */
1529         print_specific_help (0, undoc_mask, all_langs_mask);
1530         /* Then display any remaining, non-language options.  */
1531         for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1532           if (i != CL_DRIVER)
1533             print_specific_help (i, undoc_mask, 0);
1534         exit_after_options = true;
1535         break;
1536       }
1537
1538     case OPT__target_help:
1539       print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0);
1540       exit_after_options = true;
1541
1542       /* Allow the target a chance to give the user some additional information.  */
1543       if (targetm.help)
1544         targetm.help ();
1545       break;
1546
1547     case OPT__help_:
1548       {
1549         const char * a = arg;
1550         unsigned int include_flags = 0;
1551         /* Note - by default we include undocumented options when listing
1552            specific classes.  If you only want to see documented options
1553            then add ",^undocumented" to the --help= option.  E.g.:
1554
1555            --help=target,^undocumented  */
1556         unsigned int exclude_flags = 0;
1557
1558         /* Walk along the argument string, parsing each word in turn.
1559            The format is:
1560            arg = [^]{word}[,{arg}]
1561            word = {optimizers|target|warnings|undocumented|
1562                    params|common|<language>}  */
1563         while (* a != 0)
1564           {
1565             static struct
1566             {
1567               const char * string;
1568               unsigned int flag;
1569             }
1570             specifics[] =
1571             {
1572               { "optimizers", CL_OPTIMIZATION },
1573               { "target", CL_TARGET },
1574               { "warnings", CL_WARNING },
1575               { "undocumented", CL_UNDOCUMENTED },
1576               { "params", CL_PARAMS },
1577               { "joined", CL_JOINED },
1578               { "separate", CL_SEPARATE },
1579               { "common", CL_COMMON },
1580               { NULL, 0 }
1581             };
1582             unsigned int * pflags;
1583             const char * comma;
1584             unsigned int lang_flag, specific_flag;
1585             unsigned int len;
1586             unsigned int i;
1587
1588             if (* a == '^')
1589               {
1590                 ++ a;
1591                 pflags = & exclude_flags;
1592               }
1593             else
1594               pflags = & include_flags;
1595
1596             comma = strchr (a, ',');
1597             if (comma == NULL)
1598               len = strlen (a);
1599             else
1600               len = comma - a;
1601             if (len == 0)
1602               {
1603                 a = comma + 1;
1604                 continue;
1605               }
1606
1607             /* Check to see if the string matches an option class name.  */
1608             for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1609               if (strncasecmp (a, specifics[i].string, len) == 0)
1610                 {
1611                   specific_flag = specifics[i].flag;
1612                   break;
1613                 }
1614
1615             /* Check to see if the string matches a language name.
1616                Note - we rely upon the alpha-sorted nature of the entries in
1617                the lang_names array, specifically that shorter names appear
1618                before their longer variants.  (i.e. C before C++).  That way
1619                when we are attempting to match --help=c for example we will
1620                match with C first and not C++.  */
1621             for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1622               if (strncasecmp (a, lang_names[i], len) == 0)
1623                 {
1624                   lang_flag = 1U << i;
1625                   break;
1626                 }
1627
1628             if (specific_flag != 0)
1629               {
1630                 if (lang_flag == 0)
1631                   * pflags |= specific_flag;
1632                 else
1633                   {
1634                     /* The option's argument matches both the start of a
1635                        language name and the start of an option class name.
1636                        We have a special case for when the user has
1637                        specified "--help=c", but otherwise we have to issue
1638                        a warning.  */
1639                     if (strncasecmp (a, "c", len) == 0)
1640                       * pflags |= lang_flag;
1641                     else
1642                       fnotice (stderr,
1643                                "warning: --help argument %.*s is ambiguous, please be more specific\n",
1644                                len, a);
1645                   }
1646               }
1647             else if (lang_flag != 0)
1648               * pflags |= lang_flag;
1649             else
1650               fnotice (stderr,
1651                        "warning: unrecognized argument to --help= option: %.*s\n",
1652                        len, a);
1653
1654             if (comma == NULL)
1655               break;
1656             a = comma + 1;
1657           }
1658
1659         if (include_flags)
1660           print_specific_help (include_flags, exclude_flags, 0);
1661         exit_after_options = true;
1662         break;
1663       }
1664
1665     case OPT__version:
1666       exit_after_options = true;
1667       break;
1668
1669     case OPT_O:
1670     case OPT_Os:
1671     case OPT_Ofast:
1672       /* Currently handled in a prescan.  */
1673       break;
1674
1675     case OPT_Werror_:
1676       enable_warning_as_error (arg, value, lang_mask, handlers, global_dc);
1677       break;
1678
1679     case OPT_Wlarger_than_:
1680       larger_than_size = value;
1681       warn_larger_than = value != -1;
1682       break;
1683
1684     case OPT_Wfatal_errors:
1685       global_dc->fatal_errors = value;
1686       break;
1687
1688     case OPT_Wframe_larger_than_:
1689       frame_larger_than_size = value;
1690       warn_frame_larger_than = value != -1;
1691       break;
1692
1693     case OPT_Wstrict_aliasing:
1694       set_Wstrict_aliasing (value);
1695       break;
1696
1697     case OPT_Wstrict_aliasing_:
1698       warn_strict_aliasing = value;
1699       break;
1700
1701     case OPT_Wstrict_overflow:
1702       warn_strict_overflow = (value
1703                               ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1704                               : 0);
1705       break;
1706
1707     case OPT_Wstrict_overflow_:
1708       warn_strict_overflow = value;
1709       break;
1710
1711     case OPT_Wsystem_headers:
1712       global_dc->dc_warn_system_headers = value;
1713       break;
1714
1715     case OPT_Wunused:
1716       warn_unused = value;
1717       break;
1718
1719     case OPT_aux_info:
1720       aux_info_file_name = arg;
1721       flag_gen_aux_info = 1;
1722       break;
1723
1724     case OPT_auxbase:
1725       aux_base_name = arg;
1726       break;
1727
1728     case OPT_auxbase_strip:
1729       {
1730         char *tmp = xstrdup (arg);
1731         strip_off_ending (tmp, strlen (tmp));
1732         if (tmp[0])
1733           aux_base_name = tmp;
1734       }
1735       break;
1736
1737     case OPT_d:
1738       decode_d_option (arg);
1739       break;
1740
1741     case OPT_dumpbase:
1742       dump_base_name = arg;
1743       break;
1744
1745     case OPT_dumpdir:
1746       dump_dir_name = arg;
1747       break;
1748
1749     case OPT_falign_functions_:
1750       align_functions = value;
1751       break;
1752
1753     case OPT_falign_jumps_:
1754       align_jumps = value;
1755       break;
1756
1757     case OPT_falign_labels_:
1758       align_labels = value;
1759       break;
1760
1761     case OPT_falign_loops_:
1762       align_loops = value;
1763       break;
1764
1765     case OPT_fcall_used_:
1766       fix_register (arg, 0, 1);
1767       break;
1768
1769     case OPT_fcall_saved_:
1770       fix_register (arg, 0, 0);
1771       break;
1772
1773     case OPT_fcompare_debug_second:
1774       flag_compare_debug = value;
1775       break;
1776
1777     case OPT_fdbg_cnt_:
1778       dbg_cnt_process_opt (arg);
1779       break;
1780
1781     case OPT_fdbg_cnt_list:
1782       dbg_cnt_list_all_counters ();
1783       break;
1784
1785     case OPT_fdebug_prefix_map_:
1786       add_debug_prefix_map (arg);
1787       break;
1788
1789     case OPT_fdiagnostics_show_location_:
1790       if (!strcmp (arg, "once"))
1791         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
1792       else if (!strcmp (arg, "every-line"))
1793         diagnostic_prefixing_rule (global_dc)
1794           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
1795       else
1796         return false;
1797       break;
1798
1799     case OPT_fdiagnostics_show_option:
1800       global_dc->show_option_requested = value;
1801       break;
1802
1803     case OPT_fdump_:
1804       if (!dump_switch_p (arg))
1805         return false;
1806       break;
1807
1808     case OPT_fexcess_precision_:
1809       if (!strcmp (arg, "fast"))
1810         flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
1811       else if (!strcmp (arg, "standard"))
1812         flag_excess_precision_cmdline = EXCESS_PRECISION_STANDARD;
1813       else
1814         error ("unknown excess precision style \"%s\"", arg);
1815       break;
1816
1817     case OPT_ffast_math:
1818       set_fast_math_flags (value);
1819       break;
1820
1821     case OPT_funsafe_math_optimizations:
1822       set_unsafe_math_optimizations_flags (value);
1823       break;
1824
1825     case OPT_ffixed_:
1826       fix_register (arg, 1, 1);
1827       break;
1828
1829     case OPT_finline_limit_:
1830       set_param_value ("max-inline-insns-single", value / 2);
1831       set_param_value ("max-inline-insns-auto", value / 2);
1832       break;
1833
1834     case OPT_finstrument_functions_exclude_function_list_:
1835       add_comma_separated_to_vector
1836         (&flag_instrument_functions_exclude_functions, arg);
1837       break;
1838
1839     case OPT_finstrument_functions_exclude_file_list_:
1840       add_comma_separated_to_vector
1841         (&flag_instrument_functions_exclude_files, arg);
1842       break;
1843
1844     case OPT_fmessage_length_:
1845       pp_set_line_maximum_length (global_dc->printer, value);
1846       break;
1847
1848     case OPT_fpack_struct_:
1849       if (value <= 0 || (value & (value - 1)) || value > 16)
1850         error ("structure alignment must be a small power of two, not %d", value);
1851       else
1852         {
1853           initial_max_fld_align = value;
1854           maximum_field_alignment = value * BITS_PER_UNIT;
1855         }
1856       break;
1857
1858     case OPT_fplugin_:
1859 #ifdef ENABLE_PLUGIN
1860       add_new_plugin (arg);
1861 #else
1862       error ("Plugin support is disabled.  Configure with --enable-plugin.");
1863 #endif
1864       break;
1865
1866     case OPT_fplugin_arg_:
1867 #ifdef ENABLE_PLUGIN
1868       parse_plugin_arg_opt (arg);
1869 #else
1870       error ("Plugin support is disabled.  Configure with --enable-plugin.");
1871 #endif
1872       break;
1873
1874     case OPT_fprofile_dir_:
1875       profile_data_prefix = xstrdup (arg);
1876       break;
1877
1878     case OPT_fprofile_use_:
1879       profile_data_prefix = xstrdup (arg);
1880       flag_profile_use = true;
1881       value = true;
1882       /* No break here - do -fprofile-use processing. */
1883     case OPT_fprofile_use:
1884       if (!opts_set->x_flag_branch_probabilities)
1885         flag_branch_probabilities = value;
1886       if (!opts_set->x_flag_profile_values)
1887         flag_profile_values = value;
1888       if (!opts_set->x_flag_unroll_loops)
1889         flag_unroll_loops = value;
1890       if (!opts_set->x_flag_peel_loops)
1891         flag_peel_loops = value;
1892       if (!opts_set->x_flag_tracer)
1893         flag_tracer = value;
1894       if (!opts_set->x_flag_value_profile_transformations)
1895         flag_value_profile_transformations = value;
1896       if (!opts_set->x_flag_inline_functions)
1897         flag_inline_functions = value;
1898       if (!opts_set->x_flag_ipa_cp)
1899         flag_ipa_cp = value;
1900       if (!opts_set->x_flag_ipa_cp_clone
1901           && value && flag_ipa_cp)
1902         flag_ipa_cp_clone = value;
1903       if (!opts_set->x_flag_predictive_commoning)
1904         flag_predictive_commoning = value;
1905       if (!opts_set->x_flag_unswitch_loops)
1906         flag_unswitch_loops = value;
1907       if (!opts_set->x_flag_gcse_after_reload)
1908         flag_gcse_after_reload = value;
1909       break;
1910
1911     case OPT_fprofile_generate_:
1912       profile_data_prefix = xstrdup (arg);
1913       value = true;
1914       /* No break here - do -fprofile-generate processing. */
1915     case OPT_fprofile_generate:
1916       if (!opts_set->x_profile_arc_flag)
1917         profile_arc_flag = value;
1918       if (!opts_set->x_flag_profile_values)
1919         flag_profile_values = value;
1920       if (!opts_set->x_flag_value_profile_transformations)
1921         flag_value_profile_transformations = value;
1922       if (!opts_set->x_flag_inline_functions)
1923         flag_inline_functions = value;
1924       break;
1925
1926     case OPT_fshow_column:
1927       global_dc->show_column = value;
1928       break;
1929
1930     case OPT_fvisibility_:
1931       {
1932         if (!strcmp(arg, "default"))
1933           default_visibility = VISIBILITY_DEFAULT;
1934         else if (!strcmp(arg, "internal"))
1935           default_visibility = VISIBILITY_INTERNAL;
1936         else if (!strcmp(arg, "hidden"))
1937           default_visibility = VISIBILITY_HIDDEN;
1938         else if (!strcmp(arg, "protected"))
1939           default_visibility = VISIBILITY_PROTECTED;
1940         else
1941           error ("unrecognized visibility value \"%s\"", arg);
1942       }
1943       break;
1944
1945     case OPT_frandom_seed:
1946       /* The real switch is -fno-random-seed.  */
1947       if (value)
1948         return false;
1949       set_random_seed (NULL);
1950       break;
1951
1952     case OPT_frandom_seed_:
1953       set_random_seed (arg);
1954       break;
1955
1956     case OPT_fsched_verbose_:
1957 #ifdef INSN_SCHEDULING
1958       fix_sched_param ("verbose", arg);
1959       break;
1960 #else
1961       return false;
1962 #endif
1963
1964     case OPT_fsched_stalled_insns_:
1965       flag_sched_stalled_insns = value;
1966       if (flag_sched_stalled_insns == 0)
1967         flag_sched_stalled_insns = -1;
1968       break;
1969
1970     case OPT_fsched_stalled_insns_dep_:
1971       flag_sched_stalled_insns_dep = value;
1972       break;
1973
1974     case OPT_fstack_check_:
1975       if (!strcmp (arg, "no"))
1976         flag_stack_check = NO_STACK_CHECK;
1977       else if (!strcmp (arg, "generic"))
1978         /* This is the old stack checking method.  */
1979         flag_stack_check = STACK_CHECK_BUILTIN
1980                            ? FULL_BUILTIN_STACK_CHECK
1981                            : GENERIC_STACK_CHECK;
1982       else if (!strcmp (arg, "specific"))
1983         /* This is the new stack checking method.  */
1984         flag_stack_check = STACK_CHECK_BUILTIN
1985                            ? FULL_BUILTIN_STACK_CHECK
1986                            : STACK_CHECK_STATIC_BUILTIN
1987                              ? STATIC_BUILTIN_STACK_CHECK
1988                              : GENERIC_STACK_CHECK;
1989       else
1990         warning (0, "unknown stack check parameter \"%s\"", arg);
1991       break;
1992
1993     case OPT_fstack_limit:
1994       /* The real switch is -fno-stack-limit.  */
1995       if (value)
1996         return false;
1997       stack_limit_rtx = NULL_RTX;
1998       break;
1999
2000     case OPT_fstack_limit_register_:
2001       {
2002         int reg = decode_reg_name (arg);
2003         if (reg < 0)
2004           error ("unrecognized register name \"%s\"", arg);
2005         else
2006           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
2007       }
2008       break;
2009
2010     case OPT_fstack_limit_symbol_:
2011       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
2012       break;
2013
2014     case OPT_ftree_vectorizer_verbose_:
2015       vect_set_verbosity_level (arg);
2016       break;
2017
2018     case OPT_ftls_model_:
2019       if (!strcmp (arg, "global-dynamic"))
2020         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
2021       else if (!strcmp (arg, "local-dynamic"))
2022         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
2023       else if (!strcmp (arg, "initial-exec"))
2024         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
2025       else if (!strcmp (arg, "local-exec"))
2026         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
2027       else
2028         warning (0, "unknown tls-model \"%s\"", arg);
2029       break;
2030
2031     case OPT_fira_algorithm_:
2032       if (!strcmp (arg, "CB"))
2033         flag_ira_algorithm = IRA_ALGORITHM_CB;
2034       else if (!strcmp (arg, "priority"))
2035         flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
2036       else
2037         warning (0, "unknown ira algorithm \"%s\"", arg);
2038       break;
2039
2040     case OPT_fira_region_:
2041       if (!strcmp (arg, "one"))
2042         flag_ira_region = IRA_REGION_ONE;
2043       else if (!strcmp (arg, "all"))
2044         flag_ira_region = IRA_REGION_ALL;
2045       else if (!strcmp (arg, "mixed"))
2046         flag_ira_region = IRA_REGION_MIXED;
2047       else
2048         warning (0, "unknown ira region \"%s\"", arg);
2049       break;
2050
2051     case OPT_fira_verbose_:
2052       flag_ira_verbose = value;
2053       break;
2054
2055     case OPT_g:
2056       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
2057       break;
2058
2059     case OPT_gcoff:
2060       set_debug_level (SDB_DEBUG, false, arg);
2061       break;
2062
2063     case OPT_gdwarf_:
2064       if (value < 2 || value > 4)
2065         error ("dwarf version %d is not supported", value);
2066       else
2067         dwarf_version = value;
2068       set_debug_level (DWARF2_DEBUG, false, "");
2069       break;
2070
2071     case OPT_ggdb:
2072       set_debug_level (NO_DEBUG, 2, arg);
2073       break;
2074
2075     case OPT_gstabs:
2076     case OPT_gstabs_:
2077       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
2078       break;
2079
2080     case OPT_gvms:
2081       set_debug_level (VMS_DEBUG, false, arg);
2082       break;
2083
2084     case OPT_gxcoff:
2085     case OPT_gxcoff_:
2086       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
2087       break;
2088
2089     case OPT_o:
2090       asm_file_name = arg;
2091       break;
2092
2093     case OPT_pedantic_errors:
2094       flag_pedantic_errors = pedantic = 1;
2095       global_dc->pedantic_errors = 1;
2096       break;
2097
2098     case OPT_fwhopr_:
2099       flag_whopr = arg;
2100       break;
2101
2102     case OPT_fwhopr:
2103       flag_whopr = "";
2104       break;
2105
2106     case OPT_w:
2107       global_dc->dc_inhibit_warnings = true;
2108       break;
2109
2110     case OPT_fuse_linker_plugin:
2111       /* No-op. Used by the driver and passed to us because it starts with f.*/
2112       break;
2113
2114     default:
2115       /* If the flag was handled in a standard way, assume the lack of
2116          processing here is intentional.  */
2117       gcc_assert (option_flag_var (scode, opts));
2118       break;
2119     }
2120
2121   return true;
2122 }
2123
2124 /* Handle --param NAME=VALUE.  */
2125 static void
2126 handle_param (const char *carg)
2127 {
2128   char *equal, *arg;
2129   int value;
2130
2131   arg = xstrdup (carg);
2132   equal = strchr (arg, '=');
2133   if (!equal)
2134     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
2135   else
2136     {
2137       value = integral_argument (equal + 1);
2138       if (value == -1)
2139         error ("invalid --param value %qs", equal + 1);
2140       else
2141         {
2142           *equal = '\0';
2143           set_param_value (arg, value);
2144         }
2145     }
2146
2147   free (arg);
2148 }
2149
2150 /* Used to set the level of strict aliasing warnings,
2151    when no level is specified (i.e., when -Wstrict-aliasing, and not
2152    -Wstrict-aliasing=level was given).
2153    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2154    and 0 otherwise.  After calling this function, wstrict_aliasing will be
2155    set to the default value of -Wstrict_aliasing=level, currently 3.  */
2156 void
2157 set_Wstrict_aliasing (int onoff)
2158 {
2159   gcc_assert (onoff == 0 || onoff == 1);
2160   if (onoff != 0)
2161     warn_strict_aliasing = 3;
2162   else
2163     warn_strict_aliasing = 0;
2164 }
2165
2166 /* The following routines are useful in setting all the flags that
2167    -ffast-math and -fno-fast-math imply.  */
2168 void
2169 set_fast_math_flags (int set)
2170 {
2171   flag_unsafe_math_optimizations = set;
2172   set_unsafe_math_optimizations_flags (set);
2173   flag_finite_math_only = set;
2174   flag_errno_math = !set;
2175   if (set)
2176     {
2177       flag_signaling_nans = 0;
2178       flag_rounding_math = 0;
2179       flag_cx_limited_range = 1;
2180     }
2181 }
2182
2183 /* When -funsafe-math-optimizations is set the following
2184    flags are set as well.  */
2185 void
2186 set_unsafe_math_optimizations_flags (int set)
2187 {
2188   flag_trapping_math = !set;
2189   flag_signed_zeros = !set;
2190   flag_associative_math = set;
2191   flag_reciprocal_math = set;
2192 }
2193
2194 /* Return true iff flags are set as if -ffast-math.  */
2195 bool
2196 fast_math_flags_set_p (void)
2197 {
2198   return (!flag_trapping_math
2199           && flag_unsafe_math_optimizations
2200           && flag_finite_math_only
2201           && !flag_signed_zeros
2202           && !flag_errno_math);
2203 }
2204
2205 /* Return true iff flags are set as if -ffast-math but using the flags stored
2206    in the struct cl_optimization structure.  */
2207 bool
2208 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2209 {
2210   return (!opt->x_flag_trapping_math
2211           && opt->x_flag_unsafe_math_optimizations
2212           && opt->x_flag_finite_math_only
2213           && !opt->x_flag_signed_zeros
2214           && !opt->x_flag_errno_math);
2215 }
2216
2217 /* Handle a debug output -g switch.  EXTENDED is true or false to support
2218    extended output (2 is special and means "-ggdb" was given).  */
2219 static void
2220 set_debug_level (enum debug_info_type type, int extended, const char *arg)
2221 {
2222   static bool type_explicit;
2223
2224   use_gnu_debug_info_extensions = extended;
2225
2226   if (type == NO_DEBUG)
2227     {
2228       if (write_symbols == NO_DEBUG)
2229         {
2230           write_symbols = PREFERRED_DEBUGGING_TYPE;
2231
2232           if (extended == 2)
2233             {
2234 #ifdef DWARF2_DEBUGGING_INFO
2235               write_symbols = DWARF2_DEBUG;
2236 #elif defined DBX_DEBUGGING_INFO
2237               write_symbols = DBX_DEBUG;
2238 #endif
2239             }
2240
2241           if (write_symbols == NO_DEBUG)
2242             warning (0, "target system does not support debug output");
2243         }
2244     }
2245   else
2246     {
2247       /* Does it conflict with an already selected type?  */
2248       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
2249         error ("debug format \"%s\" conflicts with prior selection",
2250                debug_type_names[type]);
2251       write_symbols = type;
2252       type_explicit = true;
2253     }
2254
2255   /* A debug flag without a level defaults to level 2.  */
2256   if (*arg == '\0')
2257     {
2258       if (!debug_info_level)
2259         debug_info_level = DINFO_LEVEL_NORMAL;
2260     }
2261   else
2262     {
2263       int argval = integral_argument (arg);
2264       if (argval == -1)
2265         error ("unrecognised debug output level \"%s\"", arg);
2266       else if (argval > 3)
2267         error ("debug output level %s is too high", arg);
2268       else
2269         debug_info_level = (enum debug_info_level) argval;
2270     }
2271 }
2272
2273 /* Return 1 if option OPT_IDX is enabled in OPTS, 0 if it is disabled,
2274    or -1 if it isn't a simple on-off switch.  */
2275
2276 int
2277 option_enabled (int opt_idx, void *opts)
2278 {
2279   const struct cl_option *option = &(cl_options[opt_idx]);
2280   struct gcc_options *optsg = (struct gcc_options *) opts;
2281   void *flag_var = option_flag_var (opt_idx, optsg);
2282
2283   if (flag_var)
2284     switch (option->var_type)
2285       {
2286       case CLVC_BOOLEAN:
2287         return *(int *) flag_var != 0;
2288
2289       case CLVC_EQUAL:
2290         return *(int *) flag_var == option->var_value;
2291
2292       case CLVC_BIT_CLEAR:
2293         return (*(int *) flag_var & option->var_value) == 0;
2294
2295       case CLVC_BIT_SET:
2296         return (*(int *) flag_var & option->var_value) != 0;
2297
2298       case CLVC_STRING:
2299         break;
2300       }
2301   return -1;
2302 }
2303
2304 /* Fill STATE with the current state of option OPTION in OPTS.  Return
2305    true if there is some state to store.  */
2306
2307 bool
2308 get_option_state (struct gcc_options *opts, int option,
2309                   struct cl_option_state *state)
2310 {
2311   void *flag_var = option_flag_var (option, opts);
2312
2313   if (flag_var == 0)
2314     return false;
2315
2316   switch (cl_options[option].var_type)
2317     {
2318     case CLVC_BOOLEAN:
2319     case CLVC_EQUAL:
2320       state->data = flag_var;
2321       state->size = sizeof (int);
2322       break;
2323
2324     case CLVC_BIT_CLEAR:
2325     case CLVC_BIT_SET:
2326       state->ch = option_enabled (option, opts);
2327       state->data = &state->ch;
2328       state->size = 1;
2329       break;
2330
2331     case CLVC_STRING:
2332       state->data = *(const char **) flag_var;
2333       if (state->data == 0)
2334         state->data = "";
2335       state->size = strlen ((const char *) state->data) + 1;
2336       break;
2337     }
2338   return true;
2339 }
2340
2341 /* Callback function, called when -Werror= enables a warning.  */
2342
2343 static void (*warning_as_error_callback) (int) = NULL;
2344
2345 /* Register a callback for enable_warning_as_error calls.  */
2346
2347 void
2348 register_warning_as_error_callback (void (*callback) (int))
2349 {
2350   gcc_assert (warning_as_error_callback == NULL || callback == NULL);
2351   warning_as_error_callback = callback;
2352 }
2353
2354 /* Enable (or disable if VALUE is 0) a warning option ARG (language
2355    mask LANG_MASK, option handlers HANDLERS) as an error for
2356    diagnostic context DC (possibly NULL).  This is used by
2357    -Werror=.  */
2358
2359 void
2360 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
2361                          const struct cl_option_handlers *handlers,
2362                          diagnostic_context *dc)
2363 {
2364   char *new_option;
2365   int option_index;
2366
2367   new_option = XNEWVEC (char, strlen (arg) + 2);
2368   new_option[0] = 'W';
2369   strcpy (new_option + 1, arg);
2370   option_index = find_opt (new_option, lang_mask);
2371   if (option_index == OPT_SPECIAL_unknown)
2372     {
2373       error ("-Werror=%s: No option -%s", arg, new_option);
2374     }
2375   else
2376     {
2377       const struct cl_option *option = &cl_options[option_index];
2378       const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
2379
2380       if (option->alias_target != N_OPTS)
2381         option_index = option->alias_target;
2382       if (option_index == OPT_SPECIAL_ignore)
2383         return;
2384       if (dc)
2385         diagnostic_classify_diagnostic (dc, option_index, kind,
2386                                         UNKNOWN_LOCATION);
2387       if (kind == DK_ERROR)
2388         {
2389           const struct cl_option * const option = cl_options + option_index;
2390
2391           /* -Werror=foo implies -Wfoo.  */
2392           if (option->var_type == CLVC_BOOLEAN)
2393             handle_generated_option (&global_options, &global_options_set,
2394                                      option_index, NULL, value, lang_mask,
2395                                      (int)kind, handlers,
2396                                      dc);
2397
2398           if (warning_as_error_callback)
2399             warning_as_error_callback (option_index);
2400         }
2401     }
2402   free (new_option);
2403 }
2404
2405 /* Return malloced memory for the name of the option OPTION_INDEX
2406    which enabled a diagnostic (context CONTEXT), originally of type
2407    ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2408    as -Werror.  */
2409
2410 char *
2411 option_name (diagnostic_context *context, int option_index,
2412              diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
2413 {
2414   if (option_index)
2415     {
2416       /* A warning classified as an error.  */
2417       if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
2418           && diag_kind == DK_ERROR)
2419         return concat (cl_options[OPT_Werror_].opt_text,
2420                        /* Skip over "-W".  */
2421                        cl_options[option_index].opt_text + 2,
2422                        NULL);
2423       /* A warning with option.  */
2424       else
2425         return xstrdup (cl_options[option_index].opt_text);
2426     }
2427   /* A warning without option classified as an error.  */
2428   else if (orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
2429            || diag_kind == DK_WARNING)
2430     {
2431       if (context->warning_as_error_requested)
2432         return xstrdup (cl_options[OPT_Werror].opt_text);
2433       else
2434         return xstrdup (_("enabled by default"));
2435     }
2436   else
2437     return NULL;
2438 }