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