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