gcc/opts.c

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