gcc/opts.c

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