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