gcc/opts.c

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