gcc/opts.c

   1 /* Command line option handling.
   2    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   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
  25 #include <signal.h>
  26
  27 #ifdef HAVE_SYS_RESOURCE_H
  28 # include <sys/resource.h>
  29 #endif
  30
  31 #include "intl.h"
  32 #include "coretypes.h"
  33 #include "tm.h" /* Needed by rtl.h and used for DWARF2_DEBUGGING_INFO
  34                    and DBX_DEBUGGING_INFO.  */
  35 #include "rtl.h" /* Needed by insn-attr.h.  */
  36 #include "opts.h"
  37 #include "options.h"
  38 #include "flags.h"
  39 #include "params.h"
  40 #include "diagnostic.h"
  41 #include "opts-diagnostic.h"
  42 #include "insn-attr.h"          /* For INSN_SCHEDULING and DELAY_SLOTS.  */
  43 #include "target.h"
  44
  45 /* Run the second compilation of -fcompare-debug.  Not defined using
  46    Var in common.opt because this is used in Ada code and so must be
  47    an actual variable not a macro.  */
  48 int flag_compare_debug;
  49
  50 /* Parse the -femit-struct-debug-detailed option value
  51    and set the flag variables. */
  52
  53 #define MATCH( prefix, string ) \
  54   ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
  55    ? ((string += sizeof prefix - 1), 1) : 0)
  56
  57 void
  58 set_struct_debug_option (struct gcc_options *opts, location_t loc,
  59                          const char *spec)
  60 {
  61   /* various labels for comparison */
  62   static const char dfn_lbl[] = "dfn:", dir_lbl[] = "dir:", ind_lbl[] = "ind:";
  63   static const char ord_lbl[] = "ord:", gen_lbl[] = "gen:";
  64   static const char none_lbl[] = "none", any_lbl[] = "any";
  65   static const char base_lbl[] = "base", sys_lbl[] = "sys";
  66
  67   enum debug_struct_file files = DINFO_STRUCT_FILE_ANY;
  68   /* Default is to apply to as much as possible. */
  69   enum debug_info_usage usage = DINFO_USAGE_NUM_ENUMS;
  70   int ord = 1, gen = 1;
  71
  72   /* What usage? */
  73   if (MATCH (dfn_lbl, spec))
  74     usage = DINFO_USAGE_DFN;
  75   else if (MATCH (dir_lbl, spec))
  76     usage = DINFO_USAGE_DIR_USE;
  77   else if (MATCH (ind_lbl, spec))
  78     usage = DINFO_USAGE_IND_USE;
  79
  80   /* Generics or not? */
  81   if (MATCH (ord_lbl, spec))
  82     gen = 0;
  83   else if (MATCH (gen_lbl, spec))
  84     ord = 0;
  85
  86   /* What allowable environment? */
  87   if (MATCH (none_lbl, spec))
  88     files = DINFO_STRUCT_FILE_NONE;
  89   else if (MATCH (any_lbl, spec))
  90     files = DINFO_STRUCT_FILE_ANY;
  91   else if (MATCH (sys_lbl, spec))
  92     files = DINFO_STRUCT_FILE_SYS;
  93   else if (MATCH (base_lbl, spec))
  94     files = DINFO_STRUCT_FILE_BASE;
  95   else
  96     error_at (loc,
  97               "argument %qs to %<-femit-struct-debug-detailed%> "
  98               "not recognized",
  99               spec);
 100
 101   /* Effect the specification. */
 102   if (usage == DINFO_USAGE_NUM_ENUMS)
 103     {
 104       if (ord)
 105         {
 106           opts->x_debug_struct_ordinary[DINFO_USAGE_DFN] = files;
 107           opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE] = files;
 108           opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE] = files;
 109         }
 110       if (gen)
 111         {
 112           opts->x_debug_struct_generic[DINFO_USAGE_DFN] = files;
 113           opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE] = files;
 114           opts->x_debug_struct_generic[DINFO_USAGE_IND_USE] = files;
 115         }
 116     }
 117   else
 118     {
 119       if (ord)
 120         opts->x_debug_struct_ordinary[usage] = files;
 121       if (gen)
 122         opts->x_debug_struct_generic[usage] = files;
 123     }
 124
 125   if (*spec == ',')
 126     set_struct_debug_option (opts, loc, spec+1);
 127   else
 128     {
 129       /* No more -femit-struct-debug-detailed specifications.
 130          Do final checks. */
 131       if (*spec != '\0')
 132         error_at (loc,
 133                   "argument %qs to %<-femit-struct-debug-detailed%> unknown",
 134                   spec);
 135       if (opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE]
 136                 < opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE]
 137           || opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE]
 138                 < opts->x_debug_struct_generic[DINFO_USAGE_IND_USE])
 139         error_at (loc,
 140                   "%<-femit-struct-debug-detailed=dir:...%> must allow "
 141                   "at least as much as "
 142                   "%<-femit-struct-debug-detailed=ind:...%>");
 143     }
 144 }
 145
 146 /* Handle -ftree-vectorizer-verbose=VAL for options OPTS.  */
 147
 148 static void
 149 vect_set_verbosity_level (struct gcc_options *opts, int val)
 150 {
 151    if (val < MAX_VERBOSITY_LEVEL)
 152      opts->x_user_vect_verbosity_level = (enum vect_verbosity_levels) val;
 153    else
 154      opts->x_user_vect_verbosity_level
 155       = (enum vect_verbosity_levels) (MAX_VERBOSITY_LEVEL - 1);
 156 }
 157
 158
 159 /* Strip off a legitimate source ending from the input string NAME of
 160    length LEN.  Rather than having to know the names used by all of
 161    our front ends, we strip off an ending of a period followed by
 162    up to five characters.  (Java uses ".class".)  */
 163
 164 void
 165 strip_off_ending (char *name, int len)
 166 {
 167   int i;
 168   for (i = 2; i < 6 && len > i; i++)
 169     {
 170       if (name[len - i] == '.')
 171         {
 172           name[len - i] = '\0';
 173           break;
 174         }
 175     }
 176 }
 177
 178 /* Find the base name of a path, stripping off both directories and
 179    a single final extension. */
 180 int
 181 base_of_path (const char *path, const char **base_out)
 182 {
 183   const char *base = path;
 184   const char *dot = 0;
 185   const char *p = path;
 186   char c = *p;
 187   while (c)
 188     {
 189       if (IS_DIR_SEPARATOR(c))
 190         {
 191           base = p + 1;
 192           dot = 0;
 193         }
 194       else if (c == '.')
 195         dot = p;
 196       c = *++p;
 197     }
 198   if (!dot)
 199     dot = p;
 200   *base_out = base;
 201   return dot - base;
 202 }
 203
 204 /* What to print when a switch has no documentation.  */
 205 static const char undocumented_msg[] = N_("This switch lacks documentation");
 206
 207 typedef char *char_p; /* For DEF_VEC_P.  */
 208 DEF_VEC_P(char_p);
 209 DEF_VEC_ALLOC_P(char_p,heap);
 210
 211 static void handle_param (struct gcc_options *opts,
 212                           struct gcc_options *opts_set, location_t loc,
 213                           const char *carg);
 214 static void set_debug_level (enum debug_info_type type, int extended,
 215                              const char *arg, struct gcc_options *opts,
 216                              struct gcc_options *opts_set,
 217                              location_t loc);
 218 static void set_fast_math_flags (struct gcc_options *opts, int set);
 219 static void decode_d_option (const char *arg, struct gcc_options *opts,
 220                              location_t loc, diagnostic_context *dc);
 221 static void set_unsafe_math_optimizations_flags (struct gcc_options *opts,
 222                                                  int set);
 223 static void enable_warning_as_error (const char *arg, int value,
 224                                      unsigned int lang_mask,
 225                                      const struct cl_option_handlers *handlers,
 226                                      struct gcc_options *opts,
 227                                      struct gcc_options *opts_set,
 228                                      location_t loc,
 229                                      diagnostic_context *dc);
 230
 231 /* Handle a back-end option; arguments and return value as for
 232    handle_option.  */
 233
 234 bool
 235 target_handle_option (struct gcc_options *opts,
 236                       struct gcc_options *opts_set,
 237                       const struct cl_decoded_option *decoded,
 238                       unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
 239                       location_t loc ATTRIBUTE_UNUSED,
 240                       const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
 241                       diagnostic_context *dc)
 242 {
 243   gcc_assert (opts == &global_options);
 244   gcc_assert (opts_set == &global_options_set);
 245   gcc_assert (dc == global_dc);
 246   gcc_assert (decoded->canonical_option_num_elements <= 2);
 247   gcc_assert (kind == DK_UNSPECIFIED);
 248   /* Although the location is not passed down to
 249      targetm.handle_option, do not make assertions about its value;
 250      options may come from optimize attributes and having the correct
 251      location in the handler is not generally important.  */
 252   return targetm.handle_option (decoded->opt_index, decoded->arg,
 253                                 decoded->value);
 254 }
 255
 256 /* Add comma-separated strings to a char_p vector.  */
 257
 258 static void
 259 add_comma_separated_to_vector (void **pvec, const char *arg)
 260 {
 261   char *tmp;
 262   char *r;
 263   char *w;
 264   char *token_start;
 265   VEC(char_p,heap) *vec = (VEC(char_p,heap) *) *pvec;
 266
 267   /* We never free this string.  */
 268   tmp = xstrdup (arg);
 269
 270   r = tmp;
 271   w = tmp;
 272   token_start = tmp;
 273
 274   while (*r != '\0')
 275     {
 276       if (*r == ',')
 277         {
 278           *w++ = '\0';
 279           ++r;
 280           VEC_safe_push (char_p, heap, vec, token_start);
 281           token_start = w;
 282         }
 283       if (*r == '\\' && r[1] == ',')
 284         {
 285           *w++ = ',';
 286           r += 2;
 287         }
 288       else
 289         *w++ = *r++;
 290     }
 291   if (*token_start != '\0')
 292     VEC_safe_push (char_p, heap, vec, token_start);
 293
 294   *pvec = vec;
 295 }
 296
 297 /* Initialize OPTS and OPTS_SET before using them in parsing options.  */
 298
 299 void
 300 init_options_struct (struct gcc_options *opts, struct gcc_options *opts_set)
 301 {
 302   size_t num_params = get_num_compiler_params ();
 303
 304   *opts = global_options_init;
 305   memset (opts_set, 0, sizeof (*opts_set));
 306
 307   opts->x_param_values = XNEWVEC (int, num_params);
 308   opts_set->x_param_values = XCNEWVEC (int, num_params);
 309   init_param_values (opts->x_param_values);
 310
 311   /* Use priority coloring if cover classes is not defined for the
 312      target.  */
 313   if (targetm.ira_cover_classes == NULL)
 314     opts->x_flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
 315
 316   /* Initialize whether `char' is signed.  */
 317   opts->x_flag_signed_char = DEFAULT_SIGNED_CHAR;
 318   /* Set this to a special "uninitialized" value.  The actual default
 319      is set after target options have been processed.  */
 320   opts->x_flag_short_enums = 2;
 321
 322   /* Initialize target_flags before targetm.target_option.optimization
 323      so the latter can modify it.  */
 324   opts->x_target_flags = targetm.default_target_flags;
 325
 326   /* Some targets have ABI-specified unwind tables.  */
 327   opts->x_flag_unwind_tables = targetm.unwind_tables_default;
 328
 329   /* Some targets have other target-specific initialization.  */
 330   targetm.target_option.init_struct (opts);
 331 }
 332
 333 /* If indicated by the optimization level LEVEL (-Os if SIZE is set,
 334    -Ofast if FAST is set), apply the option DEFAULT_OPT to OPTS and
 335    OPTS_SET, diagnostic context DC, location LOC, with language mask
 336    LANG_MASK and option handlers HANDLERS.  */
 337
 338 static void
 339 maybe_default_option (struct gcc_options *opts,
 340                       struct gcc_options *opts_set,
 341                       const struct default_options *default_opt,
 342                       int level, bool size, bool fast,
 343                       unsigned int lang_mask,
 344                       const struct cl_option_handlers *handlers,
 345                       location_t loc,
 346                       diagnostic_context *dc)
 347 {
 348   const struct cl_option *option = &cl_options[default_opt->opt_index];
 349   bool enabled;
 350
 351   if (size)
 352     gcc_assert (level == 2);
 353   if (fast)
 354     gcc_assert (level == 3);
 355
 356   switch (default_opt->levels)
 357     {
 358     case OPT_LEVELS_ALL:
 359       enabled = true;
 360       break;
 361
 362     case OPT_LEVELS_0_ONLY:
 363       enabled = (level == 0);
 364       break;
 365
 366     case OPT_LEVELS_1_PLUS:
 367       enabled = (level >= 1);
 368       break;
 369
 370     case OPT_LEVELS_1_PLUS_SPEED_ONLY:
 371       enabled = (level >= 1 && !size);
 372       break;
 373
 374     case OPT_LEVELS_2_PLUS:
 375       enabled = (level >= 2);
 376       break;
 377
 378     case OPT_LEVELS_2_PLUS_SPEED_ONLY:
 379       enabled = (level >= 2 && !size);
 380       break;
 381
 382     case OPT_LEVELS_3_PLUS:
 383       enabled = (level >= 3);
 384       break;
 385
 386     case OPT_LEVELS_3_PLUS_AND_SIZE:
 387       enabled = (level >= 3 || size);
 388       break;
 389
 390     case OPT_LEVELS_SIZE:
 391       enabled = size;
 392       break;
 393
 394     case OPT_LEVELS_FAST:
 395       enabled = fast;
 396       break;
 397
 398     case OPT_LEVELS_NONE:
 399     default:
 400       gcc_unreachable ();
 401     }
 402
 403   if (enabled)
 404     handle_generated_option (opts, opts_set, default_opt->opt_index,
 405                              default_opt->arg, default_opt->value,
 406                              lang_mask, DK_UNSPECIFIED, loc,
 407                              handlers, dc);
 408   else if (default_opt->arg == NULL
 409            && !(option->flags & CL_REJECT_NEGATIVE))
 410     handle_generated_option (opts, opts_set, default_opt->opt_index,
 411                              default_opt->arg, !default_opt->value,
 412                              lang_mask, DK_UNSPECIFIED, loc,
 413                              handlers, dc);
 414 }
 415
 416 /* As indicated by the optimization level LEVEL (-Os if SIZE is set,
 417    -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
 418    OPTS and OPTS_SET, diagnostic context DC, location LOC, with
 419    language mask LANG_MASK and option handlers HANDLERS.  */
 420
 421 static void
 422 maybe_default_options (struct gcc_options *opts,
 423                        struct gcc_options *opts_set,
 424                        const struct default_options *default_opts,
 425                        int level, bool size, bool fast,
 426                        unsigned int lang_mask,
 427                        const struct cl_option_handlers *handlers,
 428                        location_t loc,
 429                        diagnostic_context *dc)
 430 {
 431   size_t i;
 432
 433   for (i = 0; default_opts[i].levels != OPT_LEVELS_NONE; i++)
 434     maybe_default_option (opts, opts_set, &default_opts[i],
 435                           level, size, fast, lang_mask, handlers, loc, dc);
 436 }
 437
 438 /* Table of options enabled by default at different levels.  */
 439
 440 static const struct default_options default_options_table[] =
 441   {
 442     /* -O1 optimizations.  */
 443     { OPT_LEVELS_1_PLUS, OPT_fdefer_pop, NULL, 1 },
 444 #ifdef DELAY_SLOTS
 445     { OPT_LEVELS_1_PLUS, OPT_fdelayed_branch, NULL, 1 },
 446 #endif
 447     { OPT_LEVELS_1_PLUS, OPT_fguess_branch_probability, NULL, 1 },
 448     { OPT_LEVELS_1_PLUS, OPT_fcprop_registers, NULL, 1 },
 449     { OPT_LEVELS_1_PLUS, OPT_fforward_propagate, NULL, 1 },
 450     { OPT_LEVELS_1_PLUS, OPT_fif_conversion, NULL, 1 },
 451     { OPT_LEVELS_1_PLUS, OPT_fif_conversion2, NULL, 1 },
 452     { OPT_LEVELS_1_PLUS, OPT_fipa_pure_const, NULL, 1 },
 453     { OPT_LEVELS_1_PLUS, OPT_fipa_reference, NULL, 1 },
 454     { OPT_LEVELS_1_PLUS, OPT_fipa_profile, NULL, 1 },
 455     { OPT_LEVELS_1_PLUS, OPT_fmerge_constants, NULL, 1 },
 456     { OPT_LEVELS_1_PLUS, OPT_fsplit_wide_types, NULL, 1 },
 457     { OPT_LEVELS_1_PLUS, OPT_ftree_ccp, NULL, 1 },
 458     { OPT_LEVELS_1_PLUS, OPT_ftree_bit_ccp, NULL, 1 },
 459     { OPT_LEVELS_1_PLUS, OPT_ftree_dce, NULL, 1 },
 460     { OPT_LEVELS_1_PLUS, OPT_ftree_dominator_opts, NULL, 1 },
 461     { OPT_LEVELS_1_PLUS, OPT_ftree_dse, NULL, 1 },
 462     { OPT_LEVELS_1_PLUS, OPT_ftree_ter, NULL, 1 },
 463     { OPT_LEVELS_1_PLUS, OPT_ftree_sra, NULL, 1 },
 464     { OPT_LEVELS_1_PLUS, OPT_ftree_copyrename, NULL, 1 },
 465     { OPT_LEVELS_1_PLUS, OPT_ftree_fre, NULL, 1 },
 466     { OPT_LEVELS_1_PLUS, OPT_ftree_copy_prop, NULL, 1 },
 467     { OPT_LEVELS_1_PLUS, OPT_ftree_sink, NULL, 1 },
 468     { OPT_LEVELS_1_PLUS, OPT_ftree_ch, NULL, 1 },
 469     { OPT_LEVELS_1_PLUS, OPT_fcombine_stack_adjustments, NULL, 1 },
 470
 471     /* -O2 optimizations.  */
 472     { OPT_LEVELS_2_PLUS, OPT_finline_small_functions, NULL, 1 },
 473     { OPT_LEVELS_2_PLUS, OPT_findirect_inlining, NULL, 1 },
 474     { OPT_LEVELS_2_PLUS, OPT_fpartial_inlining, NULL, 1 },
 475     { OPT_LEVELS_2_PLUS, OPT_fthread_jumps, NULL, 1 },
 476     { OPT_LEVELS_2_PLUS, OPT_fcrossjumping, NULL, 1 },
 477     { OPT_LEVELS_2_PLUS, OPT_foptimize_sibling_calls, NULL, 1 },
 478     { OPT_LEVELS_2_PLUS, OPT_fcse_follow_jumps, NULL, 1 },
 479     { OPT_LEVELS_2_PLUS, OPT_fgcse, NULL, 1 },
 480     { OPT_LEVELS_2_PLUS, OPT_fexpensive_optimizations, NULL, 1 },
 481     { OPT_LEVELS_2_PLUS, OPT_frerun_cse_after_loop, NULL, 1 },
 482     { OPT_LEVELS_2_PLUS, OPT_fcaller_saves, NULL, 1 },
 483     { OPT_LEVELS_2_PLUS, OPT_fpeephole2, NULL, 1 },
 484 #ifdef INSN_SCHEDULING
 485   /* Only run the pre-regalloc scheduling pass if optimizing for speed.  */
 486     { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_fschedule_insns, NULL, 1 },
 487     { OPT_LEVELS_2_PLUS, OPT_fschedule_insns2, NULL, 1 },
 488 #endif
 489     { OPT_LEVELS_2_PLUS, OPT_fregmove, NULL, 1 },
 490     { OPT_LEVELS_2_PLUS, OPT_fstrict_aliasing, NULL, 1 },
 491     { OPT_LEVELS_2_PLUS, OPT_fstrict_overflow, NULL, 1 },
 492     { OPT_LEVELS_2_PLUS, OPT_freorder_blocks, NULL, 1 },
 493     { OPT_LEVELS_2_PLUS, OPT_freorder_functions, NULL, 1 },
 494     { OPT_LEVELS_2_PLUS, OPT_ftree_vrp, NULL, 1 },
 495     { OPT_LEVELS_2_PLUS, OPT_ftree_builtin_call_dce, NULL, 1 },
 496     { OPT_LEVELS_2_PLUS, OPT_ftree_pre, NULL, 1 },
 497     { OPT_LEVELS_2_PLUS, OPT_ftree_switch_conversion, NULL, 1 },
 498     { OPT_LEVELS_2_PLUS, OPT_fipa_cp, NULL, 1 },
 499     { OPT_LEVELS_2_PLUS, OPT_fipa_sra, NULL, 1 },
 500     { OPT_LEVELS_2_PLUS, OPT_falign_loops, NULL, 1 },
 501     { OPT_LEVELS_2_PLUS, OPT_falign_jumps, NULL, 1 },
 502     { OPT_LEVELS_2_PLUS, OPT_falign_labels, NULL, 1 },
 503     { OPT_LEVELS_2_PLUS, OPT_falign_functions, NULL, 1 },
 504
 505     /* -O3 optimizations.  */
 506     { OPT_LEVELS_3_PLUS, OPT_ftree_loop_distribute_patterns, NULL, 1 },
 507     { OPT_LEVELS_3_PLUS, OPT_fpredictive_commoning, NULL, 1 },
 508     /* Inlining of functions reducing size is a good idea with -Os
 509        regardless of them being declared inline.  */
 510     { OPT_LEVELS_3_PLUS_AND_SIZE, OPT_finline_functions, NULL, 1 },
 511     { OPT_LEVELS_3_PLUS, OPT_funswitch_loops, NULL, 1 },
 512     { OPT_LEVELS_3_PLUS, OPT_fgcse_after_reload, NULL, 1 },
 513     { OPT_LEVELS_3_PLUS, OPT_ftree_vectorize, NULL, 1 },
 514     { OPT_LEVELS_3_PLUS, OPT_fipa_cp_clone, NULL, 1 },
 515
 516     /* -Ofast adds optimizations to -O3.  */
 517     { OPT_LEVELS_FAST, OPT_ffast_math, NULL, 1 },
 518
 519     { OPT_LEVELS_NONE, 0, NULL, 0 }
 520   };
 521
 522 /* Default the options in OPTS and OPTS_SET based on the optimization
 523    settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT.  */
 524 void
 525 default_options_optimization (struct gcc_options *opts,
 526                               struct gcc_options *opts_set,
 527                               struct cl_decoded_option *decoded_options,
 528                               unsigned int decoded_options_count,
 529                               location_t loc,
 530                               unsigned int lang_mask,
 531                               const struct cl_option_handlers *handlers,
 532                               diagnostic_context *dc)
 533 {
 534   unsigned int i;
 535   int opt2;
 536   int ofast = 0;
 537
 538   /* Scan to see what optimization level has been specified.  That will
 539      determine the default value of many flags.  */
 540   for (i = 1; i < decoded_options_count; i++)
 541     {
 542       struct cl_decoded_option *opt = &decoded_options[i];
 543       switch (opt->opt_index)
 544         {
 545         case OPT_O:
 546           if (*opt->arg == '\0')
 547             {
 548               opts->x_optimize = 1;
 549               opts->x_optimize_size = 0;
 550               ofast = 0;
 551             }
 552           else
 553             {
 554               const int optimize_val = integral_argument (opt->arg);
 555               if (optimize_val == -1)
 556                 error_at (loc,
 557                           "argument to %qs should be a non-negative integer",
 558                           "-O");
 559               else
 560                 {
 561                   opts->x_optimize = optimize_val;
 562                   if ((unsigned int) opts->x_optimize > 255)
 563                     opts->x_optimize = 255;
 564                   opts->x_optimize_size = 0;
 565                   ofast = 0;
 566                 }
 567             }
 568           break;
 569
 570         case OPT_Os:
 571           opts->x_optimize_size = 1;
 572
 573           /* Optimizing for size forces optimize to be 2.  */
 574           opts->x_optimize = 2;
 575           ofast = 0;
 576           break;
 577
 578         case OPT_Ofast:
 579           /* -Ofast only adds flags to -O3.  */
 580           opts->x_optimize_size = 0;
 581           opts->x_optimize = 3;
 582           ofast = 1;
 583           break;
 584
 585         default:
 586           /* Ignore other options in this prescan.  */
 587           break;
 588         }
 589     }
 590
 591   maybe_default_options (opts, opts_set, default_options_table,
 592                          opts->x_optimize, opts->x_optimize_size,
 593                          ofast, lang_mask, handlers, loc, dc);
 594
 595   /* -O2 param settings.  */
 596   opt2 = (opts->x_optimize >= 2);
 597
 598   /* Track fields in field-sensitive alias analysis.  */
 599   maybe_set_param_value
 600     (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE,
 601      opt2 ? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE),
 602      opts->x_param_values, opts_set->x_param_values);
 603
 604   /* For -O1 only do loop invariant motion for very small loops.  */
 605   maybe_set_param_value
 606     (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP,
 607      opt2 ? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP) : 1000,
 608      opts->x_param_values, opts_set->x_param_values);
 609
 610   if (opts->x_optimize_size)
 611     /* We want to crossjump as much as possible.  */
 612     maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS, 1,
 613                            opts->x_param_values, opts_set->x_param_values);
 614   else
 615     maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS,
 616                            default_param_value (PARAM_MIN_CROSSJUMP_INSNS),
 617                            opts->x_param_values, opts_set->x_param_values);
 618
 619   /* Allow default optimizations to be specified on a per-machine basis.  */
 620   maybe_default_options (opts, opts_set,
 621                          targetm.target_option.optimization_table,
 622                          opts->x_optimize, opts->x_optimize_size,
 623                          ofast, lang_mask, handlers, loc, dc);
 624 }
 625
 626 /* After all options at LOC have been read into OPTS and OPTS_SET,
 627    finalize settings of those options and diagnose incompatible
 628    combinations.  */
 629 void
 630 finish_options (struct gcc_options *opts, struct gcc_options *opts_set,
 631                 location_t loc)
 632 {
 633   enum unwind_info_type ui_except;
 634
 635   /* These assertions are because of the use of target hooks that
 636      still access global data rather than being passed an options
 637      structure pointer.  */
 638   gcc_assert (opts == &global_options);
 639   gcc_assert (opts_set = &global_options_set);
 640
 641   if (opts->x_dump_base_name && ! IS_ABSOLUTE_PATH (opts->x_dump_base_name))
 642     {
 643       /* First try to make OPTS->X_DUMP_BASE_NAME relative to the
 644          OPTS->X_DUMP_DIR_NAME directory.  Then try to make
 645          OPTS->X_DUMP_BASE_NAME relative to the OPTS->X_AUX_BASE_NAME
 646          directory, typically the directory to contain the object
 647          file.  */
 648       if (opts->x_dump_dir_name)
 649         opts->x_dump_base_name = concat (opts->x_dump_dir_name,
 650                                          opts->x_dump_base_name, NULL);
 651       else if (opts->x_aux_base_name)
 652         {
 653           const char *aux_base;
 654
 655           base_of_path (opts->x_aux_base_name, &aux_base);
 656           if (opts->x_aux_base_name != aux_base)
 657             {
 658               int dir_len = aux_base - opts->x_aux_base_name;
 659               char *new_dump_base_name =
 660                 XNEWVEC (char, strlen (opts->x_dump_base_name) + dir_len + 1);
 661
 662               /* Copy directory component from OPTS->X_AUX_BASE_NAME.  */
 663               memcpy (new_dump_base_name, opts->x_aux_base_name, dir_len);
 664               /* Append existing OPTS->X_DUMP_BASE_NAME.  */
 665               strcpy (new_dump_base_name + dir_len, opts->x_dump_base_name);
 666               opts->x_dump_base_name = new_dump_base_name;
 667             }
 668         }
 669     }
 670
 671   /* Handle related options for unit-at-a-time, toplevel-reorder, and
 672      section-anchors.  */
 673   if (!opts->x_flag_unit_at_a_time)
 674     {
 675       if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
 676         error_at (loc, "section anchors must be disabled when unit-at-a-time "
 677                   "is disabled");
 678       opts->x_flag_section_anchors = 0;
 679       if (opts->x_flag_toplevel_reorder == 1)
 680         error_at (loc, "toplevel reorder must be disabled when unit-at-a-time "
 681                   "is disabled");
 682       opts->x_flag_toplevel_reorder = 0;
 683     }
 684
 685   /* -Wmissing-noreturn is alias for -Wsuggest-attribute=noreturn.  */
 686   if (opts->x_warn_missing_noreturn)
 687     opts->x_warn_suggest_attribute_noreturn = true;
 688
 689   /* Unless the user has asked for section anchors, we disable toplevel
 690      reordering at -O0 to disable transformations that might be surprising
 691      to end users and to get -fno-toplevel-reorder tested.  */
 692   if (!opts->x_optimize
 693       && opts->x_flag_toplevel_reorder == 2
 694       && !(opts->x_flag_section_anchors && opts_set->x_flag_section_anchors))
 695     {
 696       opts->x_flag_toplevel_reorder = 0;
 697       opts->x_flag_section_anchors = 0;
 698     }
 699   if (!opts->x_flag_toplevel_reorder)
 700     {
 701       if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
 702         error_at (loc, "section anchors must be disabled when toplevel reorder"
 703                   " is disabled");
 704       opts->x_flag_section_anchors = 0;
 705     }
 706
 707   if (!opts->x_flag_opts_finished)
 708     {
 709       if (opts->x_flag_pie)
 710         opts->x_flag_pic = opts->x_flag_pie;
 711       if (opts->x_flag_pic && !opts->x_flag_pie)
 712         opts->x_flag_shlib = 1;
 713       opts->x_flag_opts_finished = false;
 714     }
 715
 716   if (opts->x_optimize == 0)
 717     {
 718       /* Inlining does not work if not optimizing,
 719          so force it not to be done.  */
 720       opts->x_warn_inline = 0;
 721       opts->x_flag_no_inline = 1;
 722     }
 723
 724   /* The optimization to partition hot and cold basic blocks into separate
 725      sections of the .o and executable files does not work (currently)
 726      with exception handling.  This is because there is no support for
 727      generating unwind info.  If opts->x_flag_exceptions is turned on
 728      we need to turn off the partitioning optimization.  */
 729
 730   ui_except = targetm.except_unwind_info ();
 731
 732   if (opts->x_flag_exceptions
 733       && opts->x_flag_reorder_blocks_and_partition
 734       && (ui_except == UI_SJLJ || ui_except == UI_TARGET))
 735     {
 736       inform (loc,
 737               "-freorder-blocks-and-partition does not work "
 738               "with exceptions on this architecture");
 739       opts->x_flag_reorder_blocks_and_partition = 0;
 740       opts->x_flag_reorder_blocks = 1;
 741     }
 742
 743   /* If user requested unwind info, then turn off the partitioning
 744      optimization.  */
 745
 746   if (opts->x_flag_unwind_tables
 747       && !targetm.unwind_tables_default
 748       && opts->x_flag_reorder_blocks_and_partition
 749       && (ui_except == UI_SJLJ || ui_except == UI_TARGET))
 750     {
 751       inform (loc,
 752               "-freorder-blocks-and-partition does not support "
 753               "unwind info on this architecture");
 754       opts->x_flag_reorder_blocks_and_partition = 0;
 755       opts->x_flag_reorder_blocks = 1;
 756     }
 757
 758   /* If the target requested unwind info, then turn off the partitioning
 759      optimization with a different message.  Likewise, if the target does not
 760      support named sections.  */
 761
 762   if (opts->x_flag_reorder_blocks_and_partition
 763       && (!targetm.have_named_sections
 764           || (opts->x_flag_unwind_tables
 765               && targetm.unwind_tables_default
 766               && (ui_except == UI_SJLJ || ui_except == UI_TARGET))))
 767     {
 768       inform (loc,
 769               "-freorder-blocks-and-partition does not work "
 770               "on this architecture");
 771       opts->x_flag_reorder_blocks_and_partition = 0;
 772       opts->x_flag_reorder_blocks = 1;
 773     }
 774
 775   /* Pipelining of outer loops is only possible when general pipelining
 776      capabilities are requested.  */
 777   if (!opts->x_flag_sel_sched_pipelining)
 778     opts->x_flag_sel_sched_pipelining_outer_loops = 0;
 779
 780   if (!targetm.ira_cover_classes
 781       && opts->x_flag_ira_algorithm == IRA_ALGORITHM_CB)
 782     {
 783       inform (loc,
 784               "-fira-algorithm=CB does not work on this architecture");
 785       opts->x_flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
 786     }
 787
 788   if (opts->x_flag_conserve_stack)
 789     {
 790       maybe_set_param_value (PARAM_LARGE_STACK_FRAME, 100,
 791                              opts->x_param_values, opts_set->x_param_values);
 792       maybe_set_param_value (PARAM_STACK_FRAME_GROWTH, 40,
 793                              opts->x_param_values, opts_set->x_param_values);
 794     }
 795   if (opts->x_flag_wpa || opts->x_flag_ltrans)
 796     {
 797       /* These passes are not WHOPR compatible yet.  */
 798       opts->x_flag_ipa_pta = 0;
 799       opts->x_flag_ipa_struct_reorg = 0;
 800     }
 801
 802   if (opts->x_flag_lto)
 803     {
 804 #ifdef ENABLE_LTO
 805       opts->x_flag_generate_lto = 1;
 806
 807       /* When generating IL, do not operate in whole-program mode.
 808          Otherwise, symbols will be privatized too early, causing link
 809          errors later.  */
 810       opts->x_flag_whole_program = 0;
 811 #else
 812       error_at (loc, "LTO support has not been enabled in this configuration");
 813 #endif
 814     }
 815   if ((opts->x_flag_lto_partition_balanced != 0) + (opts->x_flag_lto_partition_1to1 != 0)
 816        + (opts->x_flag_lto_partition_none != 0) >= 1)
 817     {
 818       if ((opts->x_flag_lto_partition_balanced != 0)
 819            + (opts->x_flag_lto_partition_1to1 != 0)
 820            + (opts->x_flag_lto_partition_none != 0) > 1)
 821         error_at (loc, "only one -flto-partition value can be specified");
 822     }
 823
 824   /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
 825      default value if they choose based on other options.  */
 826   if (opts->x_flag_split_stack == -1)
 827     opts->x_flag_split_stack = 0;
 828   else if (opts->x_flag_split_stack)
 829     {
 830       if (!targetm.supports_split_stack (true))
 831         {
 832           error_at (loc, "%<-fsplit-stack%> is not supported by "
 833                     "this compiler configuration");
 834           opts->x_flag_split_stack = 0;
 835         }
 836     }
 837 }
 838
 839 #define LEFT_COLUMN     27
 840
 841 /* Output ITEM, of length ITEM_WIDTH, in the left column,
 842    followed by word-wrapped HELP in a second column.  */
 843 static void
 844 wrap_help (const char *help,
 845            const char *item,
 846            unsigned int item_width,
 847            unsigned int columns)
 848 {
 849   unsigned int col_width = LEFT_COLUMN;
 850   unsigned int remaining, room, len;
 851
 852   remaining = strlen (help);
 853
 854   do
 855     {
 856       room = columns - 3 - MAX (col_width, item_width);
 857       if (room > columns)
 858         room = 0;
 859       len = remaining;
 860
 861       if (room < len)
 862         {
 863           unsigned int i;
 864
 865           for (i = 0; help[i]; i++)
 866             {
 867               if (i >= room && len != remaining)
 868                 break;
 869               if (help[i] == ' ')
 870                 len = i;
 871               else if ((help[i] == '-' || help[i] == '/')
 872                        && help[i + 1] != ' '
 873                        && i > 0 && ISALPHA (help[i - 1]))
 874                 len = i + 1;
 875             }
 876         }
 877
 878       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
 879       item_width = 0;
 880       while (help[len] == ' ')
 881         len++;
 882       help += len;
 883       remaining -= len;
 884     }
 885   while (remaining);
 886 }
 887
 888 /* Print help for a specific front-end, etc.  */
 889 static void
 890 print_filtered_help (unsigned int include_flags,
 891                      unsigned int exclude_flags,
 892                      unsigned int any_flags,
 893                      unsigned int columns,
 894                      struct gcc_options *opts)
 895 {
 896   unsigned int i;
 897   const char *help;
 898   bool found = false;
 899   bool displayed = false;
 900
 901   if (include_flags == CL_PARAMS)
 902     {
 903       for (i = 0; i < LAST_PARAM; i++)
 904         {
 905           const char *param = compiler_params[i].option;
 906
 907           help = compiler_params[i].help;
 908           if (help == NULL || *help == '\0')
 909             {
 910               if (exclude_flags & CL_UNDOCUMENTED)
 911                 continue;
 912               help = undocumented_msg;
 913             }
 914
 915           /* Get the translation.  */
 916           help = _(help);
 917
 918           wrap_help (help, param, strlen (param), columns);
 919         }
 920       putchar ('\n');
 921       return;
 922     }
 923
 924   if (!opts->x_help_printed)
 925     opts->x_help_printed = XCNEWVAR (char, cl_options_count);
 926
 927   for (i = 0; i < cl_options_count; i++)
 928     {
 929       char new_help[128];
 930       const struct cl_option *option = cl_options + i;
 931       unsigned int len;
 932       const char *opt;
 933       const char *tab;
 934
 935       if (include_flags == 0
 936           || ((option->flags & include_flags) != include_flags))
 937         {
 938           if ((option->flags & any_flags) == 0)
 939             continue;
 940         }
 941
 942       /* Skip unwanted switches.  */
 943       if ((option->flags & exclude_flags) != 0)
 944         continue;
 945
 946       /* The driver currently prints its own help text.  */
 947       if ((option->flags & CL_DRIVER) != 0
 948           && (option->flags & (((1U << cl_lang_count) - 1)
 949                                | CL_COMMON | CL_TARGET)) == 0)
 950         continue;
 951
 952       found = true;
 953       /* Skip switches that have already been printed.  */
 954       if (opts->x_help_printed[i])
 955         continue;
 956
 957       opts->x_help_printed[i] = true;
 958
 959       help = option->help;
 960       if (help == NULL)
 961         {
 962           if (exclude_flags & CL_UNDOCUMENTED)
 963             continue;
 964           help = undocumented_msg;
 965         }
 966
 967       /* Get the translation.  */
 968       help = _(help);
 969
 970       /* Find the gap between the name of the
 971          option and its descriptive text.  */
 972       tab = strchr (help, '\t');
 973       if (tab)
 974         {
 975           len = tab - help;
 976           opt = help;
 977           help = tab + 1;
 978         }
 979       else
 980         {
 981           opt = option->opt_text;
 982           len = strlen (opt);
 983         }
 984
 985       /* With the -Q option enabled we change the descriptive text associated
 986          with an option to be an indication of its current setting.  */
 987       if (!quiet_flag)
 988         {
 989           void *flag_var = option_flag_var (i, opts);
 990
 991           if (len < (LEFT_COLUMN + 2))
 992             strcpy (new_help, "\t\t");
 993           else
 994             strcpy (new_help, "\t");
 995
 996           if (flag_var != NULL
 997               && option->var_type != CLVC_DEFER)
 998             {
 999               if (option->flags & CL_JOINED)
1000                 {
1001                   if (option->var_type == CLVC_STRING)
1002                     {
1003                       if (* (const char **) flag_var != NULL)
1004                         snprintf (new_help + strlen (new_help),
1005                                   sizeof (new_help) - strlen (new_help),
1006                                   * (const char **) flag_var);
1007                     }
1008                   else
1009                     sprintf (new_help + strlen (new_help),
1010                              "%#x", * (int *) flag_var);
1011                 }
1012               else
1013                 strcat (new_help, option_enabled (i, opts)
1014                         ? _("[enabled]") : _("[disabled]"));
1015             }
1016
1017           help = new_help;
1018         }
1019
1020       wrap_help (help, opt, len, columns);
1021       displayed = true;
1022     }
1023
1024   if (! found)
1025     {
1026       unsigned int langs = include_flags & CL_LANG_ALL;
1027
1028       if (langs == 0)
1029         printf (_(" No options with the desired characteristics were found\n"));
1030       else
1031         {
1032           unsigned int i;
1033
1034           /* PR 31349: Tell the user how to see all of the
1035              options supported by a specific front end.  */
1036           for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1037             if ((1U << i) & langs)
1038               printf (_(" None found.  Use --help=%s to show *all* the options supported by the %s front-end\n"),
1039                       lang_names[i], lang_names[i]);
1040         }
1041
1042     }
1043   else if (! displayed)
1044     printf (_(" All options with the desired characteristics have already been displayed\n"));
1045
1046   putchar ('\n');
1047 }
1048
1049 /* Display help for a specified type of option.
1050    The options must have ALL of the INCLUDE_FLAGS set
1051    ANY of the flags in the ANY_FLAGS set
1052    and NONE of the EXCLUDE_FLAGS set.  The current option state is in
1053    OPTS.  */
1054 static void
1055 print_specific_help (unsigned int include_flags,
1056                      unsigned int exclude_flags,
1057                      unsigned int any_flags,
1058                      struct gcc_options *opts)
1059 {
1060   unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1061   const char * description = NULL;
1062   const char * descrip_extra = "";
1063   size_t i;
1064   unsigned int flag;
1065
1066   /* Sanity check: Make sure that we do not have more
1067      languages than we have bits available to enumerate them.  */
1068   gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
1069
1070   /* If we have not done so already, obtain
1071      the desired maximum width of the output.  */
1072   if (opts->x_help_columns == 0)
1073     {
1074       const char *p;
1075
1076       GET_ENVIRONMENT (p, "COLUMNS");
1077       if (p != NULL)
1078         {
1079           int value = atoi (p);
1080
1081           if (value > 0)
1082             opts->x_help_columns = value;
1083         }
1084
1085       if (opts->x_help_columns == 0)
1086         /* Use a reasonable default.  */
1087         opts->x_help_columns = 80;
1088     }
1089
1090   /* Decide upon the title for the options that we are going to display.  */
1091   for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1092     {
1093       switch (flag & include_flags)
1094         {
1095         case 0:
1096         case CL_DRIVER:
1097           break;
1098
1099         case CL_TARGET:
1100           description = _("The following options are target specific");
1101           break;
1102         case CL_WARNING:
1103           description = _("The following options control compiler warning messages");
1104           break;
1105         case CL_OPTIMIZATION:
1106           description = _("The following options control optimizations");
1107           break;
1108         case CL_COMMON:
1109           description = _("The following options are language-independent");
1110           break;
1111         case CL_PARAMS:
1112           description = _("The --param option recognizes the following as parameters");
1113           break;
1114         default:
1115           if (i >= cl_lang_count)
1116             break;
1117           if (exclude_flags & all_langs_mask)
1118             description = _("The following options are specific to just the language ");
1119           else
1120             description = _("The following options are supported by the language ");
1121           descrip_extra = lang_names [i];
1122           break;
1123         }
1124     }
1125
1126   if (description == NULL)
1127     {
1128       if (any_flags == 0)
1129         {
1130           if (include_flags & CL_UNDOCUMENTED)
1131             description = _("The following options are not documented");
1132           else if (include_flags & CL_SEPARATE)
1133             description = _("The following options take separate arguments");
1134           else if (include_flags & CL_JOINED)
1135             description = _("The following options take joined arguments");
1136           else
1137             {
1138               internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1139                               include_flags);
1140               return;
1141             }
1142         }
1143       else
1144         {
1145           if (any_flags & all_langs_mask)
1146             description = _("The following options are language-related");
1147           else
1148             description = _("The following options are language-independent");
1149         }
1150     }
1151
1152   printf ("%s%s:\n", description, descrip_extra);
1153   print_filtered_help (include_flags, exclude_flags, any_flags,
1154                        opts->x_help_columns, opts);
1155 }
1156
1157 /* Handle target- and language-independent options.  Return zero to
1158    generate an "unknown option" message.  Only options that need
1159    extra handling need to be listed here; if you simply want
1160    DECODED->value assigned to a variable, it happens automatically.  */
1161
1162 bool
1163 common_handle_option (struct gcc_options *opts,
1164                       struct gcc_options *opts_set,
1165                       const struct cl_decoded_option *decoded,
1166                       unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
1167                       location_t loc,
1168                       const struct cl_option_handlers *handlers,
1169                       diagnostic_context *dc)
1170 {
1171   size_t scode = decoded->opt_index;
1172   const char *arg = decoded->arg;
1173   int value = decoded->value;
1174   enum opt_code code = (enum opt_code) scode;
1175
1176   gcc_assert (opts == &global_options);
1177   gcc_assert (opts_set == &global_options_set);
1178   gcc_assert (dc == global_dc);
1179   gcc_assert (decoded->canonical_option_num_elements <= 2);
1180
1181   switch (code)
1182     {
1183     case OPT__param:
1184       handle_param (opts, opts_set, loc, arg);
1185       break;
1186
1187     case OPT__help:
1188       {
1189         unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1190         unsigned int undoc_mask;
1191         unsigned int i;
1192
1193         undoc_mask = ((opts->x_verbose_flag | opts->x_extra_warnings)
1194                       ? 0
1195                       : CL_UNDOCUMENTED);
1196         /* First display any single language specific options.  */
1197         for (i = 0; i < cl_lang_count; i++)
1198           print_specific_help
1199             (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0, opts);
1200         /* Next display any multi language specific options.  */
1201         print_specific_help (0, undoc_mask, all_langs_mask, opts);
1202         /* Then display any remaining, non-language options.  */
1203         for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1204           if (i != CL_DRIVER)
1205             print_specific_help (i, undoc_mask, 0, opts);
1206         opts->x_exit_after_options = true;
1207         break;
1208       }
1209
1210     case OPT__target_help:
1211       print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0, opts);
1212       opts->x_exit_after_options = true;
1213
1214       /* Allow the target a chance to give the user some additional information.  */
1215       if (targetm.help)
1216         targetm.help ();
1217       break;
1218
1219     case OPT__help_:
1220       {
1221         const char * a = arg;
1222         unsigned int include_flags = 0;
1223         /* Note - by default we include undocumented options when listing
1224            specific classes.  If you only want to see documented options
1225            then add ",^undocumented" to the --help= option.  E.g.:
1226
1227            --help=target,^undocumented  */
1228         unsigned int exclude_flags = 0;
1229
1230         /* Walk along the argument string, parsing each word in turn.
1231            The format is:
1232            arg = [^]{word}[,{arg}]
1233            word = {optimizers|target|warnings|undocumented|
1234                    params|common|<language>}  */
1235         while (* a != 0)
1236           {
1237             static const struct
1238             {
1239               const char * string;
1240               unsigned int flag;
1241             }
1242             specifics[] =
1243             {
1244               { "optimizers", CL_OPTIMIZATION },
1245               { "target", CL_TARGET },
1246               { "warnings", CL_WARNING },
1247               { "undocumented", CL_UNDOCUMENTED },
1248               { "params", CL_PARAMS },
1249               { "joined", CL_JOINED },
1250               { "separate", CL_SEPARATE },
1251               { "common", CL_COMMON },
1252               { NULL, 0 }
1253             };
1254             unsigned int * pflags;
1255             const char * comma;
1256             unsigned int lang_flag, specific_flag;
1257             unsigned int len;
1258             unsigned int i;
1259
1260             if (* a == '^')
1261               {
1262                 ++ a;
1263                 pflags = & exclude_flags;
1264               }
1265             else
1266               pflags = & include_flags;
1267
1268             comma = strchr (a, ',');
1269             if (comma == NULL)
1270               len = strlen (a);
1271             else
1272               len = comma - a;
1273             if (len == 0)
1274               {
1275                 a = comma + 1;
1276                 continue;
1277               }
1278
1279             /* Check to see if the string matches an option class name.  */
1280             for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1281               if (strncasecmp (a, specifics[i].string, len) == 0)
1282                 {
1283                   specific_flag = specifics[i].flag;
1284                   break;
1285                 }
1286
1287             /* Check to see if the string matches a language name.
1288                Note - we rely upon the alpha-sorted nature of the entries in
1289                the lang_names array, specifically that shorter names appear
1290                before their longer variants.  (i.e. C before C++).  That way
1291                when we are attempting to match --help=c for example we will
1292                match with C first and not C++.  */
1293             for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1294               if (strncasecmp (a, lang_names[i], len) == 0)
1295                 {
1296                   lang_flag = 1U << i;
1297                   break;
1298                 }
1299
1300             if (specific_flag != 0)
1301               {
1302                 if (lang_flag == 0)
1303                   * pflags |= specific_flag;
1304                 else
1305                   {
1306                     /* The option's argument matches both the start of a
1307                        language name and the start of an option class name.
1308                        We have a special case for when the user has
1309                        specified "--help=c", but otherwise we have to issue
1310                        a warning.  */
1311                     if (strncasecmp (a, "c", len) == 0)
1312                       * pflags |= lang_flag;
1313                     else
1314                       warning_at (loc, 0,
1315                                   "--help argument %q.*s is ambiguous, "
1316                                   "please be more specific",
1317                                   len, a);
1318                   }
1319               }
1320             else if (lang_flag != 0)
1321               * pflags |= lang_flag;
1322             else
1323               warning_at (loc, 0,
1324                           "unrecognized argument to --help= option: %q.*s",
1325                           len, a);
1326
1327             if (comma == NULL)
1328               break;
1329             a = comma + 1;
1330           }
1331
1332         if (include_flags)
1333           print_specific_help (include_flags, exclude_flags, 0, opts);
1334         opts->x_exit_after_options = true;
1335         break;
1336       }
1337
1338     case OPT__version:
1339       opts->x_exit_after_options = true;
1340       break;
1341
1342     case OPT_O:
1343     case OPT_Os:
1344     case OPT_Ofast:
1345       /* Currently handled in a prescan.  */
1346       break;
1347
1348     case OPT_Werror_:
1349       enable_warning_as_error (arg, value, lang_mask, handlers,
1350                                opts, opts_set, loc, dc);
1351       break;
1352
1353     case OPT_Wlarger_than_:
1354       opts->x_larger_than_size = value;
1355       opts->x_warn_larger_than = value != -1;
1356       break;
1357
1358     case OPT_Wfatal_errors:
1359       dc->fatal_errors = value;
1360       break;
1361
1362     case OPT_Wframe_larger_than_:
1363       opts->x_frame_larger_than_size = value;
1364       opts->x_warn_frame_larger_than = value != -1;
1365       break;
1366
1367     case OPT_Wstrict_aliasing:
1368       set_Wstrict_aliasing (opts, value);
1369       break;
1370
1371     case OPT_Wstrict_overflow:
1372       opts->x_warn_strict_overflow = (value
1373                                       ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1374                                       : 0);
1375       break;
1376
1377     case OPT_Wsystem_headers:
1378       dc->dc_warn_system_headers = value;
1379       break;
1380
1381     case OPT_aux_info:
1382       opts->x_flag_gen_aux_info = 1;
1383       break;
1384
1385     case OPT_auxbase_strip:
1386       {
1387         char *tmp = xstrdup (arg);
1388         strip_off_ending (tmp, strlen (tmp));
1389         if (tmp[0])
1390           opts->x_aux_base_name = tmp;
1391       }
1392       break;
1393
1394     case OPT_d:
1395       decode_d_option (arg, opts, loc, dc);
1396       break;
1397
1398     case OPT_fcall_used_:
1399     case OPT_fcall_saved_:
1400       /* Deferred.  */
1401       break;
1402
1403     case OPT_fcompare_debug_second:
1404       flag_compare_debug = value;
1405       break;
1406
1407     case OPT_fdbg_cnt_:
1408     case OPT_fdbg_cnt_list:
1409       /* Deferred.  */
1410       break;
1411
1412     case OPT_fdebug_prefix_map_:
1413       /* Deferred.  */
1414       break;
1415
1416     case OPT_fdiagnostics_show_location_:
1417       if (!strcmp (arg, "once"))
1418         diagnostic_prefixing_rule (dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
1419       else if (!strcmp (arg, "every-line"))
1420         diagnostic_prefixing_rule (dc)
1421           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
1422       else
1423         return false;
1424       break;
1425
1426     case OPT_fdiagnostics_show_option:
1427       dc->show_option_requested = value;
1428       break;
1429
1430     case OPT_fdump_:
1431       /* Deferred.  */
1432       break;
1433
1434     case OPT_ffp_contract_:
1435       if (!strcmp (arg, "on"))
1436         /* Not implemented, fall back to conservative FP_CONTRACT_OFF.  */
1437         opts->x_flag_fp_contract_mode = FP_CONTRACT_OFF;
1438       else if (!strcmp (arg, "off"))
1439         opts->x_flag_fp_contract_mode = FP_CONTRACT_OFF;
1440       else if (!strcmp (arg, "fast"))
1441         opts->x_flag_fp_contract_mode = FP_CONTRACT_FAST;
1442       else
1443         error_at (loc, "unknown floating point contraction style \"%s\"", arg);
1444       break;
1445
1446     case OPT_fexcess_precision_:
1447       if (!strcmp (arg, "fast"))
1448         opts->x_flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
1449       else if (!strcmp (arg, "standard"))
1450         opts->x_flag_excess_precision_cmdline = EXCESS_PRECISION_STANDARD;
1451       else
1452         error_at (loc, "unknown excess precision style \"%s\"", arg);
1453       break;
1454
1455     case OPT_ffast_math:
1456       set_fast_math_flags (opts, value);
1457       break;
1458
1459     case OPT_funsafe_math_optimizations:
1460       set_unsafe_math_optimizations_flags (opts, value);
1461       break;
1462
1463     case OPT_ffixed_:
1464       /* Deferred.  */
1465       break;
1466
1467     case OPT_finline_limit_:
1468       set_param_value ("max-inline-insns-single", value / 2,
1469                        opts->x_param_values, opts_set->x_param_values);
1470       set_param_value ("max-inline-insns-auto", value / 2,
1471                        opts->x_param_values, opts_set->x_param_values);
1472       break;
1473
1474     case OPT_finstrument_functions_exclude_function_list_:
1475       add_comma_separated_to_vector
1476         (&opts->x_flag_instrument_functions_exclude_functions, arg);
1477       break;
1478
1479     case OPT_finstrument_functions_exclude_file_list_:
1480       add_comma_separated_to_vector
1481         (&opts->x_flag_instrument_functions_exclude_files, arg);
1482       break;
1483
1484     case OPT_fmessage_length_:
1485       pp_set_line_maximum_length (dc->printer, value);
1486       break;
1487
1488     case OPT_fpack_struct_:
1489       if (value <= 0 || (value & (value - 1)) || value > 16)
1490         error_at (loc,
1491                   "structure alignment must be a small power of two, not %d",
1492                   value);
1493       else
1494         opts->x_initial_max_fld_align = value;
1495       break;
1496
1497     case OPT_fplugin_:
1498     case OPT_fplugin_arg_:
1499       /* Deferred.  */
1500       break;
1501
1502     case OPT_fprofile_use_:
1503       opts->x_profile_data_prefix = xstrdup (arg);
1504       opts->x_flag_profile_use = true;
1505       value = true;
1506       /* No break here - do -fprofile-use processing. */
1507     case OPT_fprofile_use:
1508       if (!opts_set->x_flag_branch_probabilities)
1509         opts->x_flag_branch_probabilities = value;
1510       if (!opts_set->x_flag_profile_values)
1511         opts->x_flag_profile_values = value;
1512       if (!opts_set->x_flag_unroll_loops)
1513         opts->x_flag_unroll_loops = value;
1514       if (!opts_set->x_flag_peel_loops)
1515         opts->x_flag_peel_loops = value;
1516       if (!opts_set->x_flag_tracer)
1517         opts->x_flag_tracer = value;
1518       if (!opts_set->x_flag_value_profile_transformations)
1519         opts->x_flag_value_profile_transformations = value;
1520       if (!opts_set->x_flag_inline_functions)
1521         opts->x_flag_inline_functions = value;
1522       if (!opts_set->x_flag_ipa_cp)
1523         opts->x_flag_ipa_cp = value;
1524       if (!opts_set->x_flag_ipa_cp_clone
1525           && value && opts->x_flag_ipa_cp)
1526         opts->x_flag_ipa_cp_clone = value;
1527       if (!opts_set->x_flag_predictive_commoning)
1528         opts->x_flag_predictive_commoning = value;
1529       if (!opts_set->x_flag_unswitch_loops)
1530         opts->x_flag_unswitch_loops = value;
1531       if (!opts_set->x_flag_gcse_after_reload)
1532         opts->x_flag_gcse_after_reload = value;
1533       break;
1534
1535     case OPT_fprofile_generate_:
1536       opts->x_profile_data_prefix = xstrdup (arg);
1537       value = true;
1538       /* No break here - do -fprofile-generate processing. */
1539     case OPT_fprofile_generate:
1540       if (!opts_set->x_profile_arc_flag)
1541         opts->x_profile_arc_flag = value;
1542       if (!opts_set->x_flag_profile_values)
1543         opts->x_flag_profile_values = value;
1544       if (!opts_set->x_flag_value_profile_transformations)
1545         opts->x_flag_value_profile_transformations = value;
1546       if (!opts_set->x_flag_inline_functions)
1547         opts->x_flag_inline_functions = value;
1548       break;
1549
1550     case OPT_fshow_column:
1551       dc->show_column = value;
1552       break;
1553
1554     case OPT_fvisibility_:
1555       {
1556         if (!strcmp(arg, "default"))
1557           opts->x_default_visibility = VISIBILITY_DEFAULT;
1558         else if (!strcmp(arg, "internal"))
1559           opts->x_default_visibility = VISIBILITY_INTERNAL;
1560         else if (!strcmp(arg, "hidden"))
1561           opts->x_default_visibility = VISIBILITY_HIDDEN;
1562         else if (!strcmp(arg, "protected"))
1563           opts->x_default_visibility = VISIBILITY_PROTECTED;
1564         else
1565           error_at (loc, "unrecognized visibility value \"%s\"", arg);
1566       }
1567       break;
1568
1569     case OPT_frandom_seed:
1570       /* The real switch is -fno-random-seed.  */
1571       if (value)
1572         return false;
1573       /* Deferred.  */
1574       break;
1575
1576     case OPT_frandom_seed_:
1577       /* Deferred.  */
1578       break;
1579
1580     case OPT_fsched_verbose_:
1581 #ifdef INSN_SCHEDULING
1582       /* Handled with Var in common.opt.  */
1583       break;
1584 #else
1585       return false;
1586 #endif
1587
1588     case OPT_fsched_stalled_insns_:
1589       opts->x_flag_sched_stalled_insns = value;
1590       if (opts->x_flag_sched_stalled_insns == 0)
1591         opts->x_flag_sched_stalled_insns = -1;
1592       break;
1593
1594     case OPT_fsched_stalled_insns_dep_:
1595       opts->x_flag_sched_stalled_insns_dep = value;
1596       break;
1597
1598     case OPT_fstack_check_:
1599       if (!strcmp (arg, "no"))
1600         flag_stack_check = NO_STACK_CHECK;
1601       else if (!strcmp (arg, "generic"))
1602         /* This is the old stack checking method.  */
1603         flag_stack_check = STACK_CHECK_BUILTIN
1604                            ? FULL_BUILTIN_STACK_CHECK
1605                            : GENERIC_STACK_CHECK;
1606       else if (!strcmp (arg, "specific"))
1607         /* This is the new stack checking method.  */
1608         flag_stack_check = STACK_CHECK_BUILTIN
1609                            ? FULL_BUILTIN_STACK_CHECK
1610                            : STACK_CHECK_STATIC_BUILTIN
1611                              ? STATIC_BUILTIN_STACK_CHECK
1612                              : GENERIC_STACK_CHECK;
1613       else
1614         warning_at (loc, 0, "unknown stack check parameter \"%s\"", arg);
1615       break;
1616
1617     case OPT_fstack_limit:
1618       /* The real switch is -fno-stack-limit.  */
1619       if (value)
1620         return false;
1621       /* Deferred.  */
1622       break;
1623
1624     case OPT_fstack_limit_register_:
1625     case OPT_fstack_limit_symbol_:
1626       /* Deferred.  */
1627       break;
1628
1629     case OPT_ftree_vectorizer_verbose_:
1630       vect_set_verbosity_level (opts, value);
1631       break;
1632
1633     case OPT_ftls_model_:
1634       if (!strcmp (arg, "global-dynamic"))
1635         opts->x_flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1636       else if (!strcmp (arg, "local-dynamic"))
1637         opts->x_flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1638       else if (!strcmp (arg, "initial-exec"))
1639         opts->x_flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1640       else if (!strcmp (arg, "local-exec"))
1641         opts->x_flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1642       else
1643         warning_at (loc, 0, "unknown tls-model \"%s\"", arg);
1644       break;
1645
1646     case OPT_fira_algorithm_:
1647       if (!strcmp (arg, "CB"))
1648         opts->x_flag_ira_algorithm = IRA_ALGORITHM_CB;
1649       else if (!strcmp (arg, "priority"))
1650         opts->x_flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1651       else
1652         warning_at (loc, 0, "unknown ira algorithm \"%s\"", arg);
1653       break;
1654
1655     case OPT_fira_region_:
1656       if (!strcmp (arg, "one"))
1657         opts->x_flag_ira_region = IRA_REGION_ONE;
1658       else if (!strcmp (arg, "all"))
1659         opts->x_flag_ira_region = IRA_REGION_ALL;
1660       else if (!strcmp (arg, "mixed"))
1661         opts->x_flag_ira_region = IRA_REGION_MIXED;
1662       else
1663         warning_at (loc, 0, "unknown ira region \"%s\"", arg);
1664       break;
1665
1666     case OPT_g:
1667       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg, opts, opts_set,
1668                        loc);
1669       break;
1670
1671     case OPT_gcoff:
1672       set_debug_level (SDB_DEBUG, false, arg, opts, opts_set, loc);
1673       break;
1674
1675     case OPT_gdwarf_:
1676       if (value < 2 || value > 4)
1677         error_at (loc, "dwarf version %d is not supported", value);
1678       else
1679         dwarf_version = value;
1680       set_debug_level (DWARF2_DEBUG, false, "", opts, opts_set, loc);
1681       break;
1682
1683     case OPT_ggdb:
1684       set_debug_level (NO_DEBUG, 2, arg, opts, opts_set, loc);
1685       break;
1686
1687     case OPT_gstabs:
1688     case OPT_gstabs_:
1689       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg, opts, opts_set,
1690                        loc);
1691       break;
1692
1693     case OPT_gvms:
1694       set_debug_level (VMS_DEBUG, false, arg, opts, opts_set, loc);
1695       break;
1696
1697     case OPT_gxcoff:
1698     case OPT_gxcoff_:
1699       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg, opts, opts_set,
1700                        loc);
1701       break;
1702
1703     case OPT_pedantic_errors:
1704       opts->x_pedantic = 1;
1705       dc->pedantic_errors = 1;
1706       break;
1707
1708     case OPT_flto:
1709       opts->x_flag_lto = "";
1710       break;
1711
1712     case OPT_w:
1713       dc->dc_inhibit_warnings = true;
1714       break;
1715
1716     case OPT_fmax_errors_:
1717       dc->max_errors = value;
1718       break;
1719
1720     case OPT_fuse_linker_plugin:
1721       /* No-op. Used by the driver and passed to us because it starts with f.*/
1722       break;
1723
1724     default:
1725       /* If the flag was handled in a standard way, assume the lack of
1726          processing here is intentional.  */
1727       gcc_assert (option_flag_var (scode, opts));
1728       break;
1729     }
1730
1731   return true;
1732 }
1733
1734 /* Handle --param NAME=VALUE.  */
1735 static void
1736 handle_param (struct gcc_options *opts, struct gcc_options *opts_set,
1737               location_t loc, const char *carg)
1738 {
1739   char *equal, *arg;
1740   int value;
1741
1742   arg = xstrdup (carg);
1743   equal = strchr (arg, '=');
1744   if (!equal)
1745     error_at (loc, "%s: --param arguments should be of the form NAME=VALUE",
1746               arg);
1747   else
1748     {
1749       value = integral_argument (equal + 1);
1750       if (value == -1)
1751         error_at (loc, "invalid --param value %qs", equal + 1);
1752       else
1753         {
1754           *equal = '\0';
1755           set_param_value (arg, value,
1756                            opts->x_param_values, opts_set->x_param_values);
1757         }
1758     }
1759
1760   free (arg);
1761 }
1762
1763 /* Used to set the level of strict aliasing warnings in OPTS,
1764    when no level is specified (i.e., when -Wstrict-aliasing, and not
1765    -Wstrict-aliasing=level was given).
1766    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
1767    and 0 otherwise.  After calling this function, wstrict_aliasing will be
1768    set to the default value of -Wstrict_aliasing=level, currently 3.  */
1769 void
1770 set_Wstrict_aliasing (struct gcc_options *opts, int onoff)
1771 {
1772   gcc_assert (onoff == 0 || onoff == 1);
1773   if (onoff != 0)
1774     opts->x_warn_strict_aliasing = 3;
1775   else
1776     opts->x_warn_strict_aliasing = 0;
1777 }
1778
1779 /* The following routines are useful in setting all the flags that
1780    -ffast-math and -fno-fast-math imply.  */
1781 static void
1782 set_fast_math_flags (struct gcc_options *opts, int set)
1783 {
1784   opts->x_flag_unsafe_math_optimizations = set;
1785   set_unsafe_math_optimizations_flags (opts, set);
1786   opts->x_flag_finite_math_only = set;
1787   opts->x_flag_errno_math = !set;
1788   if (set)
1789     {
1790       opts->x_flag_signaling_nans = 0;
1791       opts->x_flag_rounding_math = 0;
1792       opts->x_flag_cx_limited_range = 1;
1793     }
1794 }
1795
1796 /* When -funsafe-math-optimizations is set the following
1797    flags are set as well.  */
1798 static void
1799 set_unsafe_math_optimizations_flags (struct gcc_options *opts, int set)
1800 {
1801   opts->x_flag_trapping_math = !set;
1802   opts->x_flag_signed_zeros = !set;
1803   opts->x_flag_associative_math = set;
1804   opts->x_flag_reciprocal_math = set;
1805 }
1806
1807 /* Return true iff flags in OPTS are set as if -ffast-math.  */
1808 bool
1809 fast_math_flags_set_p (const struct gcc_options *opts)
1810 {
1811   return (!opts->x_flag_trapping_math
1812           && opts->x_flag_unsafe_math_optimizations
1813           && opts->x_flag_finite_math_only
1814           && !opts->x_flag_signed_zeros
1815           && !opts->x_flag_errno_math);
1816 }
1817
1818 /* Return true iff flags are set as if -ffast-math but using the flags stored
1819    in the struct cl_optimization structure.  */
1820 bool
1821 fast_math_flags_struct_set_p (struct cl_optimization *opt)
1822 {
1823   return (!opt->x_flag_trapping_math
1824           && opt->x_flag_unsafe_math_optimizations
1825           && opt->x_flag_finite_math_only
1826           && !opt->x_flag_signed_zeros
1827           && !opt->x_flag_errno_math);
1828 }
1829
1830 /* Handle a debug output -g switch for options OPTS
1831    (OPTS_SET->x_write_symbols storing whether a debug type was passed
1832    explicitly), location LOC.  EXTENDED is true or false to support
1833    extended output (2 is special and means "-ggdb" was given).  */
1834 static void
1835 set_debug_level (enum debug_info_type type, int extended, const char *arg,
1836                  struct gcc_options *opts, struct gcc_options *opts_set,
1837                  location_t loc)
1838 {
1839   opts->x_use_gnu_debug_info_extensions = extended;
1840
1841   if (type == NO_DEBUG)
1842     {
1843       if (opts->x_write_symbols == NO_DEBUG)
1844         {
1845           opts->x_write_symbols = PREFERRED_DEBUGGING_TYPE;
1846
1847           if (extended == 2)
1848             {
1849 #ifdef DWARF2_DEBUGGING_INFO
1850               opts->x_write_symbols = DWARF2_DEBUG;
1851 #elif defined DBX_DEBUGGING_INFO
1852               opts->x_write_symbols = DBX_DEBUG;
1853 #endif
1854             }
1855
1856           if (opts->x_write_symbols == NO_DEBUG)
1857             warning_at (loc, 0, "target system does not support debug output");
1858         }
1859     }
1860   else
1861     {
1862       /* Does it conflict with an already selected type?  */
1863       if (opts_set->x_write_symbols != NO_DEBUG
1864           && opts->x_write_symbols != NO_DEBUG
1865           && type != opts->x_write_symbols)
1866         error_at (loc, "debug format \"%s\" conflicts with prior selection",
1867                   debug_type_names[type]);
1868       opts->x_write_symbols = type;
1869       opts_set->x_write_symbols = type;
1870     }
1871
1872   /* A debug flag without a level defaults to level 2.  */
1873   if (*arg == '\0')
1874     {
1875       if (!opts->x_debug_info_level)
1876         opts->x_debug_info_level = DINFO_LEVEL_NORMAL;
1877     }
1878   else
1879     {
1880       int argval = integral_argument (arg);
1881       if (argval == -1)
1882         error_at (loc, "unrecognised debug output level \"%s\"", arg);
1883       else if (argval > 3)
1884         error_at (loc, "debug output level %s is too high", arg);
1885       else
1886         opts->x_debug_info_level = (enum debug_info_levels) argval;
1887     }
1888 }
1889
1890 /* Arrange to dump core on error for diagnostic context DC.  (The
1891    regular error message is still printed first, except in the case of
1892    abort ().)  */
1893
1894 static void
1895 setup_core_dumping (diagnostic_context *dc)
1896 {
1897 #ifdef SIGABRT
1898   signal (SIGABRT, SIG_DFL);
1899 #endif
1900 #if defined(HAVE_SETRLIMIT)
1901   {
1902     struct rlimit rlim;
1903     if (getrlimit (RLIMIT_CORE, &rlim) != 0)
1904       fatal_error ("getting core file size maximum limit: %m");
1905     rlim.rlim_cur = rlim.rlim_max;
1906     if (setrlimit (RLIMIT_CORE, &rlim) != 0)
1907       fatal_error ("setting core file size limit to maximum: %m");
1908   }
1909 #endif
1910   diagnostic_abort_on_error (dc);
1911 }
1912
1913 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
1914    diagnostic context DC.  */
1915
1916 static void
1917 decode_d_option (const char *arg, struct gcc_options *opts,
1918                  location_t loc, diagnostic_context *dc)
1919 {
1920   int c;
1921
1922   while (*arg)
1923     switch (c = *arg++)
1924       {
1925       case 'A':
1926         opts->x_flag_debug_asm = 1;
1927         break;
1928       case 'p':
1929         opts->x_flag_print_asm_name = 1;
1930         break;
1931       case 'P':
1932         opts->x_flag_dump_rtl_in_asm = 1;
1933         opts->x_flag_print_asm_name = 1;
1934         break;
1935       case 'v':
1936         opts->x_graph_dump_format = vcg;
1937         break;
1938       case 'x':
1939         opts->x_rtl_dump_and_exit = 1;
1940         break;
1941       case 'D': /* These are handled by the preprocessor.  */
1942       case 'I':
1943       case 'M':
1944       case 'N':
1945       case 'U':
1946         break;
1947       case 'H':
1948         setup_core_dumping (dc);
1949         break;
1950       case 'a':
1951         opts->x_flag_dump_all_passed = true;
1952         break;
1953
1954       default:
1955           warning_at (loc, 0, "unrecognized gcc debugging option: %c", c);
1956         break;
1957       }
1958 }
1959
1960 /* Enable (or disable if VALUE is 0) a warning option ARG (language
1961    mask LANG_MASK, option handlers HANDLERS) as an error for option
1962    structures OPTS and OPTS_SET, diagnostic context DC (possibly
1963    NULL), location LOC.  This is used by -Werror=.  */
1964
1965 static void
1966 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
1967                          const struct cl_option_handlers *handlers,
1968                          struct gcc_options *opts,
1969                          struct gcc_options *opts_set,
1970                          location_t loc, diagnostic_context *dc)
1971 {
1972   char *new_option;
1973   int option_index;
1974
1975   new_option = XNEWVEC (char, strlen (arg) + 2);
1976   new_option[0] = 'W';
1977   strcpy (new_option + 1, arg);
1978   option_index = find_opt (new_option, lang_mask);
1979   if (option_index == OPT_SPECIAL_unknown)
1980     {
1981       error_at (loc, "-Werror=%s: no option -%s", arg, new_option);
1982     }
1983   else
1984     {
1985       const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
1986
1987       control_warning_option (option_index, (int) kind, value,
1988                               loc, lang_mask,
1989                               handlers, opts, opts_set, dc);
1990     }
1991   free (new_option);
1992 }
1993
1994 /* Return malloced memory for the name of the option OPTION_INDEX
1995    which enabled a diagnostic (context CONTEXT), originally of type
1996    ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
1997    as -Werror.  */
1998
1999 char *
2000 option_name (diagnostic_context *context, int option_index,
2001              diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
2002 {
2003   if (option_index)
2004     {
2005       /* A warning classified as an error.  */
2006       if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
2007           && diag_kind == DK_ERROR)
2008         return concat (cl_options[OPT_Werror_].opt_text,
2009                        /* Skip over "-W".  */
2010                        cl_options[option_index].opt_text + 2,
2011                        NULL);
2012       /* A warning with option.  */
2013       else
2014         return xstrdup (cl_options[option_index].opt_text);
2015     }
2016   /* A warning without option classified as an error.  */
2017   else if (orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
2018            || diag_kind == DK_WARNING)
2019     {
2020       if (context->warning_as_error_requested)
2021         return xstrdup (cl_options[OPT_Werror].opt_text);
2022       else
2023         return xstrdup (_("enabled by default"));
2024     }
2025   else
2026     return NULL;
2027 }