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   if (opts->x_dump_base_name && ! IS_ABSOLUTE_PATH (opts->x_dump_base_name))
 636     {
 637       /* First try to make OPTS->X_DUMP_BASE_NAME relative to the
 638          OPTS->X_DUMP_DIR_NAME directory.  Then try to make
 639          OPTS->X_DUMP_BASE_NAME relative to the OPTS->X_AUX_BASE_NAME
 640          directory, typically the directory to contain the object
 641          file.  */
 642       if (opts->x_dump_dir_name)
 643         opts->x_dump_base_name = concat (opts->x_dump_dir_name,
 644                                          opts->x_dump_base_name, NULL);
 645       else if (opts->x_aux_base_name)
 646         {
 647           const char *aux_base;
 648
 649           base_of_path (opts->x_aux_base_name, &aux_base);
 650           if (opts->x_aux_base_name != aux_base)
 651             {
 652               int dir_len = aux_base - opts->x_aux_base_name;
 653               char *new_dump_base_name =
 654                 XNEWVEC (char, strlen (opts->x_dump_base_name) + dir_len + 1);
 655
 656               /* Copy directory component from OPTS->X_AUX_BASE_NAME.  */
 657               memcpy (new_dump_base_name, opts->x_aux_base_name, dir_len);
 658               /* Append existing OPTS->X_DUMP_BASE_NAME.  */
 659               strcpy (new_dump_base_name + dir_len, opts->x_dump_base_name);
 660               opts->x_dump_base_name = new_dump_base_name;
 661             }
 662         }
 663     }
 664
 665   /* Handle related options for unit-at-a-time, toplevel-reorder, and
 666      section-anchors.  */
 667   if (!opts->x_flag_unit_at_a_time)
 668     {
 669       if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
 670         error_at (loc, "section anchors must be disabled when unit-at-a-time "
 671                   "is disabled");
 672       opts->x_flag_section_anchors = 0;
 673       if (opts->x_flag_toplevel_reorder == 1)
 674         error_at (loc, "toplevel reorder must be disabled when unit-at-a-time "
 675                   "is disabled");
 676       opts->x_flag_toplevel_reorder = 0;
 677     }
 678
 679   /* -Wmissing-noreturn is alias for -Wsuggest-attribute=noreturn.  */
 680   if (opts->x_warn_missing_noreturn)
 681     opts->x_warn_suggest_attribute_noreturn = true;
 682
 683   /* Unless the user has asked for section anchors, we disable toplevel
 684      reordering at -O0 to disable transformations that might be surprising
 685      to end users and to get -fno-toplevel-reorder tested.  */
 686   if (!opts->x_optimize
 687       && opts->x_flag_toplevel_reorder == 2
 688       && !(opts->x_flag_section_anchors && opts_set->x_flag_section_anchors))
 689     {
 690       opts->x_flag_toplevel_reorder = 0;
 691       opts->x_flag_section_anchors = 0;
 692     }
 693   if (!opts->x_flag_toplevel_reorder)
 694     {
 695       if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
 696         error_at (loc, "section anchors must be disabled when toplevel reorder"
 697                   " is disabled");
 698       opts->x_flag_section_anchors = 0;
 699     }
 700
 701   if (!opts->x_flag_opts_finished)
 702     {
 703       if (opts->x_flag_pie)
 704         opts->x_flag_pic = opts->x_flag_pie;
 705       if (opts->x_flag_pic && !opts->x_flag_pie)
 706         opts->x_flag_shlib = 1;
 707       opts->x_flag_opts_finished = false;
 708     }
 709
 710   if (opts->x_optimize == 0)
 711     {
 712       /* Inlining does not work if not optimizing,
 713          so force it not to be done.  */
 714       opts->x_warn_inline = 0;
 715       opts->x_flag_no_inline = 1;
 716     }
 717
 718   /* The optimization to partition hot and cold basic blocks into separate
 719      sections of the .o and executable files does not work (currently)
 720      with exception handling.  This is because there is no support for
 721      generating unwind info.  If opts->x_flag_exceptions is turned on
 722      we need to turn off the partitioning optimization.  */
 723
 724   ui_except = targetm.except_unwind_info (opts);
 725
 726   if (opts->x_flag_exceptions
 727       && opts->x_flag_reorder_blocks_and_partition
 728       && (ui_except == UI_SJLJ || ui_except == UI_TARGET))
 729     {
 730       inform (loc,
 731               "-freorder-blocks-and-partition does not work "
 732               "with exceptions on this architecture");
 733       opts->x_flag_reorder_blocks_and_partition = 0;
 734       opts->x_flag_reorder_blocks = 1;
 735     }
 736
 737   /* If user requested unwind info, then turn off the partitioning
 738      optimization.  */
 739
 740   if (opts->x_flag_unwind_tables
 741       && !targetm.unwind_tables_default
 742       && opts->x_flag_reorder_blocks_and_partition
 743       && (ui_except == UI_SJLJ || ui_except == UI_TARGET))
 744     {
 745       inform (loc,
 746               "-freorder-blocks-and-partition does not support "
 747               "unwind info on this architecture");
 748       opts->x_flag_reorder_blocks_and_partition = 0;
 749       opts->x_flag_reorder_blocks = 1;
 750     }
 751
 752   /* If the target requested unwind info, then turn off the partitioning
 753      optimization with a different message.  Likewise, if the target does not
 754      support named sections.  */
 755
 756   if (opts->x_flag_reorder_blocks_and_partition
 757       && (!targetm.have_named_sections
 758           || (opts->x_flag_unwind_tables
 759               && targetm.unwind_tables_default
 760               && (ui_except == UI_SJLJ || ui_except == UI_TARGET))))
 761     {
 762       inform (loc,
 763               "-freorder-blocks-and-partition does not work "
 764               "on this architecture");
 765       opts->x_flag_reorder_blocks_and_partition = 0;
 766       opts->x_flag_reorder_blocks = 1;
 767     }
 768
 769   /* Pipelining of outer loops is only possible when general pipelining
 770      capabilities are requested.  */
 771   if (!opts->x_flag_sel_sched_pipelining)
 772     opts->x_flag_sel_sched_pipelining_outer_loops = 0;
 773
 774   if (!targetm.ira_cover_classes
 775       && opts->x_flag_ira_algorithm == IRA_ALGORITHM_CB)
 776     {
 777       inform (loc,
 778               "-fira-algorithm=CB does not work on this architecture");
 779       opts->x_flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
 780     }
 781
 782   if (opts->x_flag_conserve_stack)
 783     {
 784       maybe_set_param_value (PARAM_LARGE_STACK_FRAME, 100,
 785                              opts->x_param_values, opts_set->x_param_values);
 786       maybe_set_param_value (PARAM_STACK_FRAME_GROWTH, 40,
 787                              opts->x_param_values, opts_set->x_param_values);
 788     }
 789   if (opts->x_flag_wpa || opts->x_flag_ltrans)
 790     {
 791       /* These passes are not WHOPR compatible yet.  */
 792       opts->x_flag_ipa_pta = 0;
 793       opts->x_flag_ipa_struct_reorg = 0;
 794     }
 795
 796   if (opts->x_flag_lto)
 797     {
 798 #ifdef ENABLE_LTO
 799       opts->x_flag_generate_lto = 1;
 800
 801       /* When generating IL, do not operate in whole-program mode.
 802          Otherwise, symbols will be privatized too early, causing link
 803          errors later.  */
 804       opts->x_flag_whole_program = 0;
 805 #else
 806       error_at (loc, "LTO support has not been enabled in this configuration");
 807 #endif
 808     }
 809   if ((opts->x_flag_lto_partition_balanced != 0) + (opts->x_flag_lto_partition_1to1 != 0)
 810        + (opts->x_flag_lto_partition_none != 0) >= 1)
 811     {
 812       if ((opts->x_flag_lto_partition_balanced != 0)
 813            + (opts->x_flag_lto_partition_1to1 != 0)
 814            + (opts->x_flag_lto_partition_none != 0) > 1)
 815         error_at (loc, "only one -flto-partition value can be specified");
 816     }
 817
 818   /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
 819      default value if they choose based on other options.  */
 820   if (opts->x_flag_split_stack == -1)
 821     opts->x_flag_split_stack = 0;
 822   else if (opts->x_flag_split_stack)
 823     {
 824       if (!targetm.supports_split_stack (true, opts))
 825         {
 826           error_at (loc, "%<-fsplit-stack%> is not supported by "
 827                     "this compiler configuration");
 828           opts->x_flag_split_stack = 0;
 829         }
 830     }
 831 }
 832
 833 #define LEFT_COLUMN     27
 834
 835 /* Output ITEM, of length ITEM_WIDTH, in the left column,
 836    followed by word-wrapped HELP in a second column.  */
 837 static void
 838 wrap_help (const char *help,
 839            const char *item,
 840            unsigned int item_width,
 841            unsigned int columns)
 842 {
 843   unsigned int col_width = LEFT_COLUMN;
 844   unsigned int remaining, room, len;
 845
 846   remaining = strlen (help);
 847
 848   do
 849     {
 850       room = columns - 3 - MAX (col_width, item_width);
 851       if (room > columns)
 852         room = 0;
 853       len = remaining;
 854
 855       if (room < len)
 856         {
 857           unsigned int i;
 858
 859           for (i = 0; help[i]; i++)
 860             {
 861               if (i >= room && len != remaining)
 862                 break;
 863               if (help[i] == ' ')
 864                 len = i;
 865               else if ((help[i] == '-' || help[i] == '/')
 866                        && help[i + 1] != ' '
 867                        && i > 0 && ISALPHA (help[i - 1]))
 868                 len = i + 1;
 869             }
 870         }
 871
 872       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
 873       item_width = 0;
 874       while (help[len] == ' ')
 875         len++;
 876       help += len;
 877       remaining -= len;
 878     }
 879   while (remaining);
 880 }
 881
 882 /* Print help for a specific front-end, etc.  */
 883 static void
 884 print_filtered_help (unsigned int include_flags,
 885                      unsigned int exclude_flags,
 886                      unsigned int any_flags,
 887                      unsigned int columns,
 888                      struct gcc_options *opts,
 889                      unsigned int lang_mask)
 890 {
 891   unsigned int i;
 892   const char *help;
 893   bool found = false;
 894   bool displayed = false;
 895
 896   if (include_flags == CL_PARAMS)
 897     {
 898       for (i = 0; i < LAST_PARAM; i++)
 899         {
 900           const char *param = compiler_params[i].option;
 901
 902           help = compiler_params[i].help;
 903           if (help == NULL || *help == '\0')
 904             {
 905               if (exclude_flags & CL_UNDOCUMENTED)
 906                 continue;
 907               help = undocumented_msg;
 908             }
 909
 910           /* Get the translation.  */
 911           help = _(help);
 912
 913           wrap_help (help, param, strlen (param), columns);
 914         }
 915       putchar ('\n');
 916       return;
 917     }
 918
 919   if (!opts->x_help_printed)
 920     opts->x_help_printed = XCNEWVAR (char, cl_options_count);
 921
 922   if (!opts->x_help_enum_printed)
 923     opts->x_help_enum_printed = XCNEWVAR (char, cl_enums_count);
 924
 925   for (i = 0; i < cl_options_count; i++)
 926     {
 927       char new_help[128];
 928       const struct cl_option *option = cl_options + i;
 929       unsigned int len;
 930       const char *opt;
 931       const char *tab;
 932
 933       if (include_flags == 0
 934           || ((option->flags & include_flags) != include_flags))
 935         {
 936           if ((option->flags & any_flags) == 0)
 937             continue;
 938         }
 939
 940       /* Skip unwanted switches.  */
 941       if ((option->flags & exclude_flags) != 0)
 942         continue;
 943
 944       /* The driver currently prints its own help text.  */
 945       if ((option->flags & CL_DRIVER) != 0
 946           && (option->flags & (((1U << cl_lang_count) - 1)
 947                                | CL_COMMON | CL_TARGET)) == 0)
 948         continue;
 949
 950       found = true;
 951       /* Skip switches that have already been printed.  */
 952       if (opts->x_help_printed[i])
 953         continue;
 954
 955       opts->x_help_printed[i] = true;
 956
 957       help = option->help;
 958       if (help == NULL)
 959         {
 960           if (exclude_flags & CL_UNDOCUMENTED)
 961             continue;
 962           help = undocumented_msg;
 963         }
 964
 965       /* Get the translation.  */
 966       help = _(help);
 967
 968       /* Find the gap between the name of the
 969          option and its descriptive text.  */
 970       tab = strchr (help, '\t');
 971       if (tab)
 972         {
 973           len = tab - help;
 974           opt = help;
 975           help = tab + 1;
 976         }
 977       else
 978         {
 979           opt = option->opt_text;
 980           len = strlen (opt);
 981         }
 982
 983       /* With the -Q option enabled we change the descriptive text associated
 984          with an option to be an indication of its current setting.  */
 985       if (!quiet_flag)
 986         {
 987           void *flag_var = option_flag_var (i, opts);
 988
 989           if (len < (LEFT_COLUMN + 2))
 990             strcpy (new_help, "\t\t");
 991           else
 992             strcpy (new_help, "\t");
 993
 994           if (flag_var != NULL
 995               && option->var_type != CLVC_DEFER)
 996             {
 997               if (option->flags & CL_JOINED)
 998                 {
 999                   if (option->var_type == CLVC_STRING)
1000                     {
1001                       if (* (const char **) flag_var != NULL)
1002                         snprintf (new_help + strlen (new_help),
1003                                   sizeof (new_help) - strlen (new_help),
1004                                   * (const char **) flag_var);
1005                     }
1006                   else if (option->var_type == CLVC_ENUM)
1007                     {
1008                       const struct cl_enum *e = &cl_enums[option->var_enum];
1009                       int value;
1010                       const char *arg = NULL;
1011
1012                       value = e->get (flag_var);
1013                       enum_value_to_arg (e->values, &arg, value, lang_mask);
1014                       if (arg == NULL)
1015                         arg = _("[default]");
1016                       snprintf (new_help + strlen (new_help),
1017                                 sizeof (new_help) - strlen (new_help),
1018                                 arg);
1019                     }
1020                   else
1021                     sprintf (new_help + strlen (new_help),
1022                              "%#x", * (int *) flag_var);
1023                 }
1024               else
1025                 strcat (new_help, option_enabled (i, opts)
1026                         ? _("[enabled]") : _("[disabled]"));
1027             }
1028
1029           help = new_help;
1030         }
1031
1032       wrap_help (help, opt, len, columns);
1033       displayed = true;
1034
1035       if (option->var_type == CLVC_ENUM
1036           && opts->x_help_enum_printed[option->var_enum] != 2)
1037         opts->x_help_enum_printed[option->var_enum] = 1;
1038     }
1039
1040   if (! found)
1041     {
1042       unsigned int langs = include_flags & CL_LANG_ALL;
1043
1044       if (langs == 0)
1045         printf (_(" No options with the desired characteristics were found\n"));
1046       else
1047         {
1048           unsigned int i;
1049
1050           /* PR 31349: Tell the user how to see all of the
1051              options supported by a specific front end.  */
1052           for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1053             if ((1U << i) & langs)
1054               printf (_(" None found.  Use --help=%s to show *all* the options supported by the %s front-end\n"),
1055                       lang_names[i], lang_names[i]);
1056         }
1057
1058     }
1059   else if (! displayed)
1060     printf (_(" All options with the desired characteristics have already been displayed\n"));
1061
1062   putchar ('\n');
1063
1064   /* Print details of enumerated option arguments, if those
1065      enumerations have help text headings provided.  If no help text
1066      is provided, presume that the possible values are listed in the
1067      help text for the relevant options.  */
1068   for (i = 0; i < cl_enums_count; i++)
1069     {
1070       unsigned int j, pos;
1071
1072       if (opts->x_help_enum_printed[i] != 1)
1073         continue;
1074       if (cl_enums[i].help == NULL)
1075         continue;
1076       printf ("  %s\n    ", _(cl_enums[i].help));
1077       pos = 4;
1078       for (j = 0; cl_enums[i].values[j].arg != NULL; j++)
1079         {
1080           unsigned int len = strlen (cl_enums[i].values[j].arg);
1081
1082           if (pos > 4 && pos + 1 + len <= columns)
1083             {
1084               printf (" %s", cl_enums[i].values[j].arg);
1085               pos += 1 + len;
1086             }
1087           else
1088             {
1089               if (pos > 4)
1090                 {
1091                   printf ("\n    ");
1092                   pos = 4;
1093                 }
1094               printf ("%s", cl_enums[i].values[j].arg);
1095               pos += len;
1096             }
1097         }
1098       printf ("\n\n");
1099       opts->x_help_enum_printed[i] = 2;
1100     }
1101 }
1102
1103 /* Display help for a specified type of option.
1104    The options must have ALL of the INCLUDE_FLAGS set
1105    ANY of the flags in the ANY_FLAGS set
1106    and NONE of the EXCLUDE_FLAGS set.  The current option state is in
1107    OPTS; LANG_MASK is used for interpreting enumerated option state.  */
1108 static void
1109 print_specific_help (unsigned int include_flags,
1110                      unsigned int exclude_flags,
1111                      unsigned int any_flags,
1112                      struct gcc_options *opts,
1113                      unsigned int lang_mask)
1114 {
1115   unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1116   const char * description = NULL;
1117   const char * descrip_extra = "";
1118   size_t i;
1119   unsigned int flag;
1120
1121   /* Sanity check: Make sure that we do not have more
1122      languages than we have bits available to enumerate them.  */
1123   gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
1124
1125   /* If we have not done so already, obtain
1126      the desired maximum width of the output.  */
1127   if (opts->x_help_columns == 0)
1128     {
1129       const char *p;
1130
1131       GET_ENVIRONMENT (p, "COLUMNS");
1132       if (p != NULL)
1133         {
1134           int value = atoi (p);
1135
1136           if (value > 0)
1137             opts->x_help_columns = value;
1138         }
1139
1140       if (opts->x_help_columns == 0)
1141         /* Use a reasonable default.  */
1142         opts->x_help_columns = 80;
1143     }
1144
1145   /* Decide upon the title for the options that we are going to display.  */
1146   for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1147     {
1148       switch (flag & include_flags)
1149         {
1150         case 0:
1151         case CL_DRIVER:
1152           break;
1153
1154         case CL_TARGET:
1155           description = _("The following options are target specific");
1156           break;
1157         case CL_WARNING:
1158           description = _("The following options control compiler warning messages");
1159           break;
1160         case CL_OPTIMIZATION:
1161           description = _("The following options control optimizations");
1162           break;
1163         case CL_COMMON:
1164           description = _("The following options are language-independent");
1165           break;
1166         case CL_PARAMS:
1167           description = _("The --param option recognizes the following as parameters");
1168           break;
1169         default:
1170           if (i >= cl_lang_count)
1171             break;
1172           if (exclude_flags & all_langs_mask)
1173             description = _("The following options are specific to just the language ");
1174           else
1175             description = _("The following options are supported by the language ");
1176           descrip_extra = lang_names [i];
1177           break;
1178         }
1179     }
1180
1181   if (description == NULL)
1182     {
1183       if (any_flags == 0)
1184         {
1185           if (include_flags & CL_UNDOCUMENTED)
1186             description = _("The following options are not documented");
1187           else if (include_flags & CL_SEPARATE)
1188             description = _("The following options take separate arguments");
1189           else if (include_flags & CL_JOINED)
1190             description = _("The following options take joined arguments");
1191           else
1192             {
1193               internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1194                               include_flags);
1195               return;
1196             }
1197         }
1198       else
1199         {
1200           if (any_flags & all_langs_mask)
1201             description = _("The following options are language-related");
1202           else
1203             description = _("The following options are language-independent");
1204         }
1205     }
1206
1207   printf ("%s%s:\n", description, descrip_extra);
1208   print_filtered_help (include_flags, exclude_flags, any_flags,
1209                        opts->x_help_columns, opts, lang_mask);
1210 }
1211
1212 /* Handle target- and language-independent options.  Return zero to
1213    generate an "unknown option" message.  Only options that need
1214    extra handling need to be listed here; if you simply want
1215    DECODED->value assigned to a variable, it happens automatically.  */
1216
1217 bool
1218 common_handle_option (struct gcc_options *opts,
1219                       struct gcc_options *opts_set,
1220                       const struct cl_decoded_option *decoded,
1221                       unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
1222                       location_t loc,
1223                       const struct cl_option_handlers *handlers,
1224                       diagnostic_context *dc)
1225 {
1226   size_t scode = decoded->opt_index;
1227   const char *arg = decoded->arg;
1228   int value = decoded->value;
1229   enum opt_code code = (enum opt_code) scode;
1230
1231   gcc_assert (decoded->canonical_option_num_elements <= 2);
1232
1233   switch (code)
1234     {
1235     case OPT__param:
1236       handle_param (opts, opts_set, loc, arg);
1237       break;
1238
1239     case OPT__help:
1240       {
1241         unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1242         unsigned int undoc_mask;
1243         unsigned int i;
1244
1245         undoc_mask = ((opts->x_verbose_flag | opts->x_extra_warnings)
1246                       ? 0
1247                       : CL_UNDOCUMENTED);
1248         /* First display any single language specific options.  */
1249         for (i = 0; i < cl_lang_count; i++)
1250           print_specific_help
1251             (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0, opts,
1252              lang_mask);
1253         /* Next display any multi language specific options.  */
1254         print_specific_help (0, undoc_mask, all_langs_mask, opts, lang_mask);
1255         /* Then display any remaining, non-language options.  */
1256         for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1257           if (i != CL_DRIVER)
1258             print_specific_help (i, undoc_mask, 0, opts, lang_mask);
1259         opts->x_exit_after_options = true;
1260         break;
1261       }
1262
1263     case OPT__target_help:
1264       print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0, opts, lang_mask);
1265       opts->x_exit_after_options = true;
1266
1267       /* Allow the target a chance to give the user some additional information.  */
1268       if (targetm.help)
1269         targetm.help ();
1270       break;
1271
1272     case OPT__help_:
1273       {
1274         const char * a = arg;
1275         unsigned int include_flags = 0;
1276         /* Note - by default we include undocumented options when listing
1277            specific classes.  If you only want to see documented options
1278            then add ",^undocumented" to the --help= option.  E.g.:
1279
1280            --help=target,^undocumented  */
1281         unsigned int exclude_flags = 0;
1282
1283         /* Walk along the argument string, parsing each word in turn.
1284            The format is:
1285            arg = [^]{word}[,{arg}]
1286            word = {optimizers|target|warnings|undocumented|
1287                    params|common|<language>}  */
1288         while (* a != 0)
1289           {
1290             static const struct
1291             {
1292               const char * string;
1293               unsigned int flag;
1294             }
1295             specifics[] =
1296             {
1297               { "optimizers", CL_OPTIMIZATION },
1298               { "target", CL_TARGET },
1299               { "warnings", CL_WARNING },
1300               { "undocumented", CL_UNDOCUMENTED },
1301               { "params", CL_PARAMS },
1302               { "joined", CL_JOINED },
1303               { "separate", CL_SEPARATE },
1304               { "common", CL_COMMON },
1305               { NULL, 0 }
1306             };
1307             unsigned int * pflags;
1308             const char * comma;
1309             unsigned int lang_flag, specific_flag;
1310             unsigned int len;
1311             unsigned int i;
1312
1313             if (* a == '^')
1314               {
1315                 ++ a;
1316                 pflags = & exclude_flags;
1317               }
1318             else
1319               pflags = & include_flags;
1320
1321             comma = strchr (a, ',');
1322             if (comma == NULL)
1323               len = strlen (a);
1324             else
1325               len = comma - a;
1326             if (len == 0)
1327               {
1328                 a = comma + 1;
1329                 continue;
1330               }
1331
1332             /* Check to see if the string matches an option class name.  */
1333             for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1334               if (strncasecmp (a, specifics[i].string, len) == 0)
1335                 {
1336                   specific_flag = specifics[i].flag;
1337                   break;
1338                 }
1339
1340             /* Check to see if the string matches a language name.
1341                Note - we rely upon the alpha-sorted nature of the entries in
1342                the lang_names array, specifically that shorter names appear
1343                before their longer variants.  (i.e. C before C++).  That way
1344                when we are attempting to match --help=c for example we will
1345                match with C first and not C++.  */
1346             for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1347               if (strncasecmp (a, lang_names[i], len) == 0)
1348                 {
1349                   lang_flag = 1U << i;
1350                   break;
1351                 }
1352
1353             if (specific_flag != 0)
1354               {
1355                 if (lang_flag == 0)
1356                   * pflags |= specific_flag;
1357                 else
1358                   {
1359                     /* The option's argument matches both the start of a
1360                        language name and the start of an option class name.
1361                        We have a special case for when the user has
1362                        specified "--help=c", but otherwise we have to issue
1363                        a warning.  */
1364                     if (strncasecmp (a, "c", len) == 0)
1365                       * pflags |= lang_flag;
1366                     else
1367                       warning_at (loc, 0,
1368                                   "--help argument %q.*s is ambiguous, "
1369                                   "please be more specific",
1370                                   len, a);
1371                   }
1372               }
1373             else if (lang_flag != 0)
1374               * pflags |= lang_flag;
1375             else
1376               warning_at (loc, 0,
1377                           "unrecognized argument to --help= option: %q.*s",
1378                           len, a);
1379
1380             if (comma == NULL)
1381               break;
1382             a = comma + 1;
1383           }
1384
1385         if (include_flags)
1386           print_specific_help (include_flags, exclude_flags, 0, opts,
1387                                lang_mask);
1388         opts->x_exit_after_options = true;
1389         break;
1390       }
1391
1392     case OPT__version:
1393       opts->x_exit_after_options = true;
1394       break;
1395
1396     case OPT_O:
1397     case OPT_Os:
1398     case OPT_Ofast:
1399       /* Currently handled in a prescan.  */
1400       break;
1401
1402     case OPT_Werror_:
1403       enable_warning_as_error (arg, value, lang_mask, handlers,
1404                                opts, opts_set, loc, dc);
1405       break;
1406
1407     case OPT_Wlarger_than_:
1408       opts->x_larger_than_size = value;
1409       opts->x_warn_larger_than = value != -1;
1410       break;
1411
1412     case OPT_Wfatal_errors:
1413       dc->fatal_errors = value;
1414       break;
1415
1416     case OPT_Wframe_larger_than_:
1417       opts->x_frame_larger_than_size = value;
1418       opts->x_warn_frame_larger_than = value != -1;
1419       break;
1420
1421     case OPT_Wstrict_aliasing:
1422       set_Wstrict_aliasing (opts, value);
1423       break;
1424
1425     case OPT_Wstrict_overflow:
1426       opts->x_warn_strict_overflow = (value
1427                                       ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1428                                       : 0);
1429       break;
1430
1431     case OPT_Wsystem_headers:
1432       dc->dc_warn_system_headers = value;
1433       break;
1434
1435     case OPT_aux_info:
1436       opts->x_flag_gen_aux_info = 1;
1437       break;
1438
1439     case OPT_auxbase_strip:
1440       {
1441         char *tmp = xstrdup (arg);
1442         strip_off_ending (tmp, strlen (tmp));
1443         if (tmp[0])
1444           opts->x_aux_base_name = tmp;
1445       }
1446       break;
1447
1448     case OPT_d:
1449       decode_d_option (arg, opts, loc, dc);
1450       break;
1451
1452     case OPT_fcall_used_:
1453     case OPT_fcall_saved_:
1454       /* Deferred.  */
1455       break;
1456
1457     case OPT_fcompare_debug_second:
1458       flag_compare_debug = value;
1459       break;
1460
1461     case OPT_fdbg_cnt_:
1462     case OPT_fdbg_cnt_list:
1463       /* Deferred.  */
1464       break;
1465
1466     case OPT_fdebug_prefix_map_:
1467       /* Deferred.  */
1468       break;
1469
1470     case OPT_fdiagnostics_show_location_:
1471       diagnostic_prefixing_rule (dc) = (diagnostic_prefixing_rule_t) value;
1472       break;
1473
1474     case OPT_fdiagnostics_show_option:
1475       dc->show_option_requested = value;
1476       break;
1477
1478     case OPT_fdump_:
1479       /* Deferred.  */
1480       break;
1481
1482     case OPT_ffast_math:
1483       set_fast_math_flags (opts, value);
1484       break;
1485
1486     case OPT_funsafe_math_optimizations:
1487       set_unsafe_math_optimizations_flags (opts, value);
1488       break;
1489
1490     case OPT_ffixed_:
1491       /* Deferred.  */
1492       break;
1493
1494     case OPT_finline_limit_:
1495       set_param_value ("max-inline-insns-single", value / 2,
1496                        opts->x_param_values, opts_set->x_param_values);
1497       set_param_value ("max-inline-insns-auto", value / 2,
1498                        opts->x_param_values, opts_set->x_param_values);
1499       break;
1500
1501     case OPT_finstrument_functions_exclude_function_list_:
1502       add_comma_separated_to_vector
1503         (&opts->x_flag_instrument_functions_exclude_functions, arg);
1504       break;
1505
1506     case OPT_finstrument_functions_exclude_file_list_:
1507       add_comma_separated_to_vector
1508         (&opts->x_flag_instrument_functions_exclude_files, arg);
1509       break;
1510
1511     case OPT_fmessage_length_:
1512       pp_set_line_maximum_length (dc->printer, value);
1513       break;
1514
1515     case OPT_fpack_struct_:
1516       if (value <= 0 || (value & (value - 1)) || value > 16)
1517         error_at (loc,
1518                   "structure alignment must be a small power of two, not %d",
1519                   value);
1520       else
1521         opts->x_initial_max_fld_align = value;
1522       break;
1523
1524     case OPT_fplugin_:
1525     case OPT_fplugin_arg_:
1526       /* Deferred.  */
1527       break;
1528
1529     case OPT_fprofile_use_:
1530       opts->x_profile_data_prefix = xstrdup (arg);
1531       opts->x_flag_profile_use = true;
1532       value = true;
1533       /* No break here - do -fprofile-use processing. */
1534     case OPT_fprofile_use:
1535       if (!opts_set->x_flag_branch_probabilities)
1536         opts->x_flag_branch_probabilities = value;
1537       if (!opts_set->x_flag_profile_values)
1538         opts->x_flag_profile_values = value;
1539       if (!opts_set->x_flag_unroll_loops)
1540         opts->x_flag_unroll_loops = value;
1541       if (!opts_set->x_flag_peel_loops)
1542         opts->x_flag_peel_loops = value;
1543       if (!opts_set->x_flag_tracer)
1544         opts->x_flag_tracer = value;
1545       if (!opts_set->x_flag_value_profile_transformations)
1546         opts->x_flag_value_profile_transformations = value;
1547       if (!opts_set->x_flag_inline_functions)
1548         opts->x_flag_inline_functions = value;
1549       if (!opts_set->x_flag_ipa_cp)
1550         opts->x_flag_ipa_cp = value;
1551       if (!opts_set->x_flag_ipa_cp_clone
1552           && value && opts->x_flag_ipa_cp)
1553         opts->x_flag_ipa_cp_clone = value;
1554       if (!opts_set->x_flag_predictive_commoning)
1555         opts->x_flag_predictive_commoning = value;
1556       if (!opts_set->x_flag_unswitch_loops)
1557         opts->x_flag_unswitch_loops = value;
1558       if (!opts_set->x_flag_gcse_after_reload)
1559         opts->x_flag_gcse_after_reload = value;
1560       break;
1561
1562     case OPT_fprofile_generate_:
1563       opts->x_profile_data_prefix = xstrdup (arg);
1564       value = true;
1565       /* No break here - do -fprofile-generate processing. */
1566     case OPT_fprofile_generate:
1567       if (!opts_set->x_profile_arc_flag)
1568         opts->x_profile_arc_flag = value;
1569       if (!opts_set->x_flag_profile_values)
1570         opts->x_flag_profile_values = value;
1571       if (!opts_set->x_flag_value_profile_transformations)
1572         opts->x_flag_value_profile_transformations = value;
1573       if (!opts_set->x_flag_inline_functions)
1574         opts->x_flag_inline_functions = value;
1575       break;
1576
1577     case OPT_fshow_column:
1578       dc->show_column = value;
1579       break;
1580
1581     case OPT_frandom_seed:
1582       /* The real switch is -fno-random-seed.  */
1583       if (value)
1584         return false;
1585       /* Deferred.  */
1586       break;
1587
1588     case OPT_frandom_seed_:
1589       /* Deferred.  */
1590       break;
1591
1592     case OPT_fsched_verbose_:
1593 #ifdef INSN_SCHEDULING
1594       /* Handled with Var in common.opt.  */
1595       break;
1596 #else
1597       return false;
1598 #endif
1599
1600     case OPT_fsched_stalled_insns_:
1601       opts->x_flag_sched_stalled_insns = value;
1602       if (opts->x_flag_sched_stalled_insns == 0)
1603         opts->x_flag_sched_stalled_insns = -1;
1604       break;
1605
1606     case OPT_fsched_stalled_insns_dep_:
1607       opts->x_flag_sched_stalled_insns_dep = value;
1608       break;
1609
1610     case OPT_fstack_check_:
1611       if (!strcmp (arg, "no"))
1612         flag_stack_check = NO_STACK_CHECK;
1613       else if (!strcmp (arg, "generic"))
1614         /* This is the old stack checking method.  */
1615         flag_stack_check = STACK_CHECK_BUILTIN
1616                            ? FULL_BUILTIN_STACK_CHECK
1617                            : GENERIC_STACK_CHECK;
1618       else if (!strcmp (arg, "specific"))
1619         /* This is the new stack checking method.  */
1620         flag_stack_check = STACK_CHECK_BUILTIN
1621                            ? FULL_BUILTIN_STACK_CHECK
1622                            : STACK_CHECK_STATIC_BUILTIN
1623                              ? STATIC_BUILTIN_STACK_CHECK
1624                              : GENERIC_STACK_CHECK;
1625       else
1626         warning_at (loc, 0, "unknown stack check parameter \"%s\"", arg);
1627       break;
1628
1629     case OPT_fstack_limit:
1630       /* The real switch is -fno-stack-limit.  */
1631       if (value)
1632         return false;
1633       /* Deferred.  */
1634       break;
1635
1636     case OPT_fstack_limit_register_:
1637     case OPT_fstack_limit_symbol_:
1638       /* Deferred.  */
1639       break;
1640
1641     case OPT_ftree_vectorizer_verbose_:
1642       vect_set_verbosity_level (opts, value);
1643       break;
1644
1645     case OPT_g:
1646       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg, opts, opts_set,
1647                        loc);
1648       break;
1649
1650     case OPT_gcoff:
1651       set_debug_level (SDB_DEBUG, false, arg, opts, opts_set, loc);
1652       break;
1653
1654     case OPT_gdwarf_:
1655       if (value < 2 || value > 4)
1656         error_at (loc, "dwarf version %d is not supported", value);
1657       else
1658         dwarf_version = value;
1659       set_debug_level (DWARF2_DEBUG, false, "", opts, opts_set, loc);
1660       break;
1661
1662     case OPT_ggdb:
1663       set_debug_level (NO_DEBUG, 2, arg, opts, opts_set, loc);
1664       break;
1665
1666     case OPT_gstabs:
1667     case OPT_gstabs_:
1668       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg, opts, opts_set,
1669                        loc);
1670       break;
1671
1672     case OPT_gvms:
1673       set_debug_level (VMS_DEBUG, false, arg, opts, opts_set, loc);
1674       break;
1675
1676     case OPT_gxcoff:
1677     case OPT_gxcoff_:
1678       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg, opts, opts_set,
1679                        loc);
1680       break;
1681
1682     case OPT_pedantic_errors:
1683       opts->x_pedantic = 1;
1684       dc->pedantic_errors = 1;
1685       break;
1686
1687     case OPT_flto:
1688       opts->x_flag_lto = "";
1689       break;
1690
1691     case OPT_w:
1692       dc->dc_inhibit_warnings = true;
1693       break;
1694
1695     case OPT_fmax_errors_:
1696       dc->max_errors = value;
1697       break;
1698
1699     case OPT_fuse_linker_plugin:
1700       /* No-op. Used by the driver and passed to us because it starts with f.*/
1701       break;
1702
1703     default:
1704       /* If the flag was handled in a standard way, assume the lack of
1705          processing here is intentional.  */
1706       gcc_assert (option_flag_var (scode, opts));
1707       break;
1708     }
1709
1710   return true;
1711 }
1712
1713 /* Handle --param NAME=VALUE.  */
1714 static void
1715 handle_param (struct gcc_options *opts, struct gcc_options *opts_set,
1716               location_t loc, const char *carg)
1717 {
1718   char *equal, *arg;
1719   int value;
1720
1721   arg = xstrdup (carg);
1722   equal = strchr (arg, '=');
1723   if (!equal)
1724     error_at (loc, "%s: --param arguments should be of the form NAME=VALUE",
1725               arg);
1726   else
1727     {
1728       value = integral_argument (equal + 1);
1729       if (value == -1)
1730         error_at (loc, "invalid --param value %qs", equal + 1);
1731       else
1732         {
1733           *equal = '\0';
1734           set_param_value (arg, value,
1735                            opts->x_param_values, opts_set->x_param_values);
1736         }
1737     }
1738
1739   free (arg);
1740 }
1741
1742 /* Used to set the level of strict aliasing warnings in OPTS,
1743    when no level is specified (i.e., when -Wstrict-aliasing, and not
1744    -Wstrict-aliasing=level was given).
1745    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
1746    and 0 otherwise.  After calling this function, wstrict_aliasing will be
1747    set to the default value of -Wstrict_aliasing=level, currently 3.  */
1748 void
1749 set_Wstrict_aliasing (struct gcc_options *opts, int onoff)
1750 {
1751   gcc_assert (onoff == 0 || onoff == 1);
1752   if (onoff != 0)
1753     opts->x_warn_strict_aliasing = 3;
1754   else
1755     opts->x_warn_strict_aliasing = 0;
1756 }
1757
1758 /* The following routines are useful in setting all the flags that
1759    -ffast-math and -fno-fast-math imply.  */
1760 static void
1761 set_fast_math_flags (struct gcc_options *opts, int set)
1762 {
1763   opts->x_flag_unsafe_math_optimizations = set;
1764   set_unsafe_math_optimizations_flags (opts, set);
1765   opts->x_flag_finite_math_only = set;
1766   opts->x_flag_errno_math = !set;
1767   if (set)
1768     {
1769       opts->x_flag_signaling_nans = 0;
1770       opts->x_flag_rounding_math = 0;
1771       opts->x_flag_cx_limited_range = 1;
1772     }
1773 }
1774
1775 /* When -funsafe-math-optimizations is set the following
1776    flags are set as well.  */
1777 static void
1778 set_unsafe_math_optimizations_flags (struct gcc_options *opts, int set)
1779 {
1780   opts->x_flag_trapping_math = !set;
1781   opts->x_flag_signed_zeros = !set;
1782   opts->x_flag_associative_math = set;
1783   opts->x_flag_reciprocal_math = set;
1784 }
1785
1786 /* Return true iff flags in OPTS are set as if -ffast-math.  */
1787 bool
1788 fast_math_flags_set_p (const struct gcc_options *opts)
1789 {
1790   return (!opts->x_flag_trapping_math
1791           && opts->x_flag_unsafe_math_optimizations
1792           && opts->x_flag_finite_math_only
1793           && !opts->x_flag_signed_zeros
1794           && !opts->x_flag_errno_math);
1795 }
1796
1797 /* Return true iff flags are set as if -ffast-math but using the flags stored
1798    in the struct cl_optimization structure.  */
1799 bool
1800 fast_math_flags_struct_set_p (struct cl_optimization *opt)
1801 {
1802   return (!opt->x_flag_trapping_math
1803           && opt->x_flag_unsafe_math_optimizations
1804           && opt->x_flag_finite_math_only
1805           && !opt->x_flag_signed_zeros
1806           && !opt->x_flag_errno_math);
1807 }
1808
1809 /* Handle a debug output -g switch for options OPTS
1810    (OPTS_SET->x_write_symbols storing whether a debug type was passed
1811    explicitly), location LOC.  EXTENDED is true or false to support
1812    extended output (2 is special and means "-ggdb" was given).  */
1813 static void
1814 set_debug_level (enum debug_info_type type, int extended, const char *arg,
1815                  struct gcc_options *opts, struct gcc_options *opts_set,
1816                  location_t loc)
1817 {
1818   opts->x_use_gnu_debug_info_extensions = extended;
1819
1820   if (type == NO_DEBUG)
1821     {
1822       if (opts->x_write_symbols == NO_DEBUG)
1823         {
1824           opts->x_write_symbols = PREFERRED_DEBUGGING_TYPE;
1825
1826           if (extended == 2)
1827             {
1828 #ifdef DWARF2_DEBUGGING_INFO
1829               opts->x_write_symbols = DWARF2_DEBUG;
1830 #elif defined DBX_DEBUGGING_INFO
1831               opts->x_write_symbols = DBX_DEBUG;
1832 #endif
1833             }
1834
1835           if (opts->x_write_symbols == NO_DEBUG)
1836             warning_at (loc, 0, "target system does not support debug output");
1837         }
1838     }
1839   else
1840     {
1841       /* Does it conflict with an already selected type?  */
1842       if (opts_set->x_write_symbols != NO_DEBUG
1843           && opts->x_write_symbols != NO_DEBUG
1844           && type != opts->x_write_symbols)
1845         error_at (loc, "debug format \"%s\" conflicts with prior selection",
1846                   debug_type_names[type]);
1847       opts->x_write_symbols = type;
1848       opts_set->x_write_symbols = type;
1849     }
1850
1851   /* A debug flag without a level defaults to level 2.  */
1852   if (*arg == '\0')
1853     {
1854       if (!opts->x_debug_info_level)
1855         opts->x_debug_info_level = DINFO_LEVEL_NORMAL;
1856     }
1857   else
1858     {
1859       int argval = integral_argument (arg);
1860       if (argval == -1)
1861         error_at (loc, "unrecognised debug output level \"%s\"", arg);
1862       else if (argval > 3)
1863         error_at (loc, "debug output level %s is too high", arg);
1864       else
1865         opts->x_debug_info_level = (enum debug_info_levels) argval;
1866     }
1867 }
1868
1869 /* Arrange to dump core on error for diagnostic context DC.  (The
1870    regular error message is still printed first, except in the case of
1871    abort ().)  */
1872
1873 static void
1874 setup_core_dumping (diagnostic_context *dc)
1875 {
1876 #ifdef SIGABRT
1877   signal (SIGABRT, SIG_DFL);
1878 #endif
1879 #if defined(HAVE_SETRLIMIT)
1880   {
1881     struct rlimit rlim;
1882     if (getrlimit (RLIMIT_CORE, &rlim) != 0)
1883       fatal_error ("getting core file size maximum limit: %m");
1884     rlim.rlim_cur = rlim.rlim_max;
1885     if (setrlimit (RLIMIT_CORE, &rlim) != 0)
1886       fatal_error ("setting core file size limit to maximum: %m");
1887   }
1888 #endif
1889   diagnostic_abort_on_error (dc);
1890 }
1891
1892 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
1893    diagnostic context DC.  */
1894
1895 static void
1896 decode_d_option (const char *arg, struct gcc_options *opts,
1897                  location_t loc, diagnostic_context *dc)
1898 {
1899   int c;
1900
1901   while (*arg)
1902     switch (c = *arg++)
1903       {
1904       case 'A':
1905         opts->x_flag_debug_asm = 1;
1906         break;
1907       case 'p':
1908         opts->x_flag_print_asm_name = 1;
1909         break;
1910       case 'P':
1911         opts->x_flag_dump_rtl_in_asm = 1;
1912         opts->x_flag_print_asm_name = 1;
1913         break;
1914       case 'v':
1915         opts->x_graph_dump_format = vcg;
1916         break;
1917       case 'x':
1918         opts->x_rtl_dump_and_exit = 1;
1919         break;
1920       case 'D': /* These are handled by the preprocessor.  */
1921       case 'I':
1922       case 'M':
1923       case 'N':
1924       case 'U':
1925         break;
1926       case 'H':
1927         setup_core_dumping (dc);
1928         break;
1929       case 'a':
1930         opts->x_flag_dump_all_passed = true;
1931         break;
1932
1933       default:
1934           warning_at (loc, 0, "unrecognized gcc debugging option: %c", c);
1935         break;
1936       }
1937 }
1938
1939 /* Enable (or disable if VALUE is 0) a warning option ARG (language
1940    mask LANG_MASK, option handlers HANDLERS) as an error for option
1941    structures OPTS and OPTS_SET, diagnostic context DC (possibly
1942    NULL), location LOC.  This is used by -Werror=.  */
1943
1944 static void
1945 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
1946                          const struct cl_option_handlers *handlers,
1947                          struct gcc_options *opts,
1948                          struct gcc_options *opts_set,
1949                          location_t loc, diagnostic_context *dc)
1950 {
1951   char *new_option;
1952   int option_index;
1953
1954   new_option = XNEWVEC (char, strlen (arg) + 2);
1955   new_option[0] = 'W';
1956   strcpy (new_option + 1, arg);
1957   option_index = find_opt (new_option, lang_mask);
1958   if (option_index == OPT_SPECIAL_unknown)
1959     {
1960       error_at (loc, "-Werror=%s: no option -%s", arg, new_option);
1961     }
1962   else
1963     {
1964       const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
1965
1966       control_warning_option (option_index, (int) kind, value,
1967                               loc, lang_mask,
1968                               handlers, opts, opts_set, dc);
1969     }
1970   free (new_option);
1971 }
1972
1973 /* Return malloced memory for the name of the option OPTION_INDEX
1974    which enabled a diagnostic (context CONTEXT), originally of type
1975    ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
1976    as -Werror.  */
1977
1978 char *
1979 option_name (diagnostic_context *context, int option_index,
1980              diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
1981 {
1982   if (option_index)
1983     {
1984       /* A warning classified as an error.  */
1985       if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
1986           && diag_kind == DK_ERROR)
1987         return concat (cl_options[OPT_Werror_].opt_text,
1988                        /* Skip over "-W".  */
1989                        cl_options[option_index].opt_text + 2,
1990                        NULL);
1991       /* A warning with option.  */
1992       else
1993         return xstrdup (cl_options[option_index].opt_text);
1994     }
1995   /* A warning without option classified as an error.  */
1996   else if (orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
1997            || diag_kind == DK_WARNING)
1998     {
1999       if (context->warning_as_error_requested)
2000         return xstrdup (cl_options[OPT_Werror].opt_text);
2001       else
2002         return xstrdup (_("enabled by default"));
2003     }
2004   else
2005     return NULL;
2006 }