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