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