gcc/opts.c

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