gcc/opts.c

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