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