gcc/opts.c

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