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