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