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