gcc/opts.c

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