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