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