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 }
 788   if ((opts->x_flag_lto_partition_balanced != 0) + (opts->x_flag_lto_partition_1to1 != 0)
 789        + (opts->x_flag_lto_partition_none != 0) >= 1)
 790     {
 791       if ((opts->x_flag_lto_partition_balanced != 0)
 792            + (opts->x_flag_lto_partition_1to1 != 0)
 793            + (opts->x_flag_lto_partition_none != 0) > 1)
 794         error_at (loc, "only one -flto-partition value can be specified");
 795     }
 796
 797   /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
 798      default value if they choose based on other options.  */
 799   if (opts->x_flag_split_stack == -1)
 800     opts->x_flag_split_stack = 0;
 801   else if (opts->x_flag_split_stack)
 802     {
 803       if (!targetm_common.supports_split_stack (true, opts))
 804         {
 805           error_at (loc, "%<-fsplit-stack%> is not supported by "
 806                     "this compiler configuration");
 807           opts->x_flag_split_stack = 0;
 808         }
 809     }
 810
 811   /* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
 812      is disabled.  */
 813   if (!opts->x_flag_tree_vectorize || !opts->x_flag_tree_loop_if_convert)
 814     maybe_set_param_value (PARAM_MAX_STORES_TO_SINK, 0,
 815                            opts->x_param_values, opts_set->x_param_values);
 816
 817   /* This replaces set_Wunused.  */
 818   if (opts->x_warn_unused_function == -1)
 819     opts->x_warn_unused_function = opts->x_warn_unused;
 820   if (opts->x_warn_unused_label == -1)
 821     opts->x_warn_unused_label = opts->x_warn_unused;
 822   /* Wunused-parameter is enabled if both -Wunused -Wextra are enabled.  */
 823   if (opts->x_warn_unused_parameter == -1)
 824     opts->x_warn_unused_parameter = (opts->x_warn_unused
 825                                      && opts->x_extra_warnings);
 826   if (opts->x_warn_unused_variable == -1)
 827     opts->x_warn_unused_variable = opts->x_warn_unused;
 828   /* Wunused-but-set-parameter is enabled if both -Wunused -Wextra are
 829      enabled.  */
 830   if (opts->x_warn_unused_but_set_parameter == -1)
 831     opts->x_warn_unused_but_set_parameter = (opts->x_warn_unused
 832                                              && opts->x_extra_warnings);
 833   if (opts->x_warn_unused_but_set_variable == -1)
 834     opts->x_warn_unused_but_set_variable = opts->x_warn_unused;
 835   if (opts->x_warn_unused_value == -1)
 836     opts->x_warn_unused_value = opts->x_warn_unused;
 837
 838   /* This replaces set_Wextra.  */
 839   if (opts->x_warn_uninitialized == -1)
 840     opts->x_warn_uninitialized = opts->x_extra_warnings;
 841 }
 842
 843 #define LEFT_COLUMN     27
 844
 845 /* Output ITEM, of length ITEM_WIDTH, in the left column,
 846    followed by word-wrapped HELP in a second column.  */
 847 static void
 848 wrap_help (const char *help,
 849            const char *item,
 850            unsigned int item_width,
 851            unsigned int columns)
 852 {
 853   unsigned int col_width = LEFT_COLUMN;
 854   unsigned int remaining, room, len;
 855
 856   remaining = strlen (help);
 857
 858   do
 859     {
 860       room = columns - 3 - MAX (col_width, item_width);
 861       if (room > columns)
 862         room = 0;
 863       len = remaining;
 864
 865       if (room < len)
 866         {
 867           unsigned int i;
 868
 869           for (i = 0; help[i]; i++)
 870             {
 871               if (i >= room && len != remaining)
 872                 break;
 873               if (help[i] == ' ')
 874                 len = i;
 875               else if ((help[i] == '-' || help[i] == '/')
 876                        && help[i + 1] != ' '
 877                        && i > 0 && ISALPHA (help[i - 1]))
 878                 len = i + 1;
 879             }
 880         }
 881
 882       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
 883       item_width = 0;
 884       while (help[len] == ' ')
 885         len++;
 886       help += len;
 887       remaining -= len;
 888     }
 889   while (remaining);
 890 }
 891
 892 /* Print help for a specific front-end, etc.  */
 893 static void
 894 print_filtered_help (unsigned int include_flags,
 895                      unsigned int exclude_flags,
 896                      unsigned int any_flags,
 897                      unsigned int columns,
 898                      struct gcc_options *opts,
 899                      unsigned int lang_mask)
 900 {
 901   unsigned int i;
 902   const char *help;
 903   bool found = false;
 904   bool displayed = false;
 905
 906   if (include_flags == CL_PARAMS)
 907     {
 908       for (i = 0; i < LAST_PARAM; i++)
 909         {
 910           const char *param = compiler_params[i].option;
 911
 912           help = compiler_params[i].help;
 913           if (help == NULL || *help == '\0')
 914             {
 915               if (exclude_flags & CL_UNDOCUMENTED)
 916                 continue;
 917               help = undocumented_msg;
 918             }
 919
 920           /* Get the translation.  */
 921           help = _(help);
 922
 923           wrap_help (help, param, strlen (param), columns);
 924         }
 925       putchar ('\n');
 926       return;
 927     }
 928
 929   if (!opts->x_help_printed)
 930     opts->x_help_printed = XCNEWVAR (char, cl_options_count);
 931
 932   if (!opts->x_help_enum_printed)
 933     opts->x_help_enum_printed = XCNEWVAR (char, cl_enums_count);
 934
 935   for (i = 0; i < cl_options_count; i++)
 936     {
 937       char new_help[128];
 938       const struct cl_option *option = cl_options + i;
 939       unsigned int len;
 940       const char *opt;
 941       const char *tab;
 942
 943       if (include_flags == 0
 944           || ((option->flags & include_flags) != include_flags))
 945         {
 946           if ((option->flags & any_flags) == 0)
 947             continue;
 948         }
 949
 950       /* Skip unwanted switches.  */
 951       if ((option->flags & exclude_flags) != 0)
 952         continue;
 953
 954       /* The driver currently prints its own help text.  */
 955       if ((option->flags & CL_DRIVER) != 0
 956           && (option->flags & (((1U << cl_lang_count) - 1)
 957                                | CL_COMMON | CL_TARGET)) == 0)
 958         continue;
 959
 960       found = true;
 961       /* Skip switches that have already been printed.  */
 962       if (opts->x_help_printed[i])
 963         continue;
 964
 965       opts->x_help_printed[i] = true;
 966
 967       help = option->help;
 968       if (help == NULL)
 969         {
 970           if (exclude_flags & CL_UNDOCUMENTED)
 971             continue;
 972           help = undocumented_msg;
 973         }
 974
 975       /* Get the translation.  */
 976       help = _(help);
 977
 978       /* Find the gap between the name of the
 979          option and its descriptive text.  */
 980       tab = strchr (help, '\t');
 981       if (tab)
 982         {
 983           len = tab - help;
 984           opt = help;
 985           help = tab + 1;
 986         }
 987       else
 988         {
 989           opt = option->opt_text;
 990           len = strlen (opt);
 991         }
 992
 993       /* With the -Q option enabled we change the descriptive text associated
 994          with an option to be an indication of its current setting.  */
 995       if (!opts->x_quiet_flag)
 996         {
 997           void *flag_var = option_flag_var (i, opts);
 998
 999           if (len < (LEFT_COLUMN + 2))
1000             strcpy (new_help, "\t\t");
1001           else
1002             strcpy (new_help, "\t");
1003
1004           if (flag_var != NULL
1005               && option->var_type != CLVC_DEFER)
1006             {
1007               if (option->flags & CL_JOINED)
1008                 {
1009                   if (option->var_type == CLVC_STRING)
1010                     {
1011                       if (* (const char **) flag_var != NULL)
1012                         snprintf (new_help + strlen (new_help),
1013                                   sizeof (new_help) - strlen (new_help),
1014                                   * (const char **) flag_var);
1015                     }
1016                   else if (option->var_type == CLVC_ENUM)
1017                     {
1018                       const struct cl_enum *e = &cl_enums[option->var_enum];
1019                       int value;
1020                       const char *arg = NULL;
1021
1022                       value = e->get (flag_var);
1023                       enum_value_to_arg (e->values, &arg, value, lang_mask);
1024                       if (arg == NULL)
1025                         arg = _("[default]");
1026                       snprintf (new_help + strlen (new_help),
1027                                 sizeof (new_help) - strlen (new_help),
1028                                 arg);
1029                     }
1030                   else
1031                     sprintf (new_help + strlen (new_help),
1032                              "%#x", * (int *) flag_var);
1033                 }
1034               else
1035                 strcat (new_help, option_enabled (i, opts)
1036                         ? _("[enabled]") : _("[disabled]"));
1037             }
1038
1039           help = new_help;
1040         }
1041
1042       wrap_help (help, opt, len, columns);
1043       displayed = true;
1044
1045       if (option->var_type == CLVC_ENUM
1046           && opts->x_help_enum_printed[option->var_enum] != 2)
1047         opts->x_help_enum_printed[option->var_enum] = 1;
1048     }
1049
1050   if (! found)
1051     {
1052       unsigned int langs = include_flags & CL_LANG_ALL;
1053
1054       if (langs == 0)
1055         printf (_(" No options with the desired characteristics were found\n"));
1056       else
1057         {
1058           unsigned int i;
1059
1060           /* PR 31349: Tell the user how to see all of the
1061              options supported by a specific front end.  */
1062           for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1063             if ((1U << i) & langs)
1064               printf (_(" None found.  Use --help=%s to show *all* the options supported by the %s front-end\n"),
1065                       lang_names[i], lang_names[i]);
1066         }
1067
1068     }
1069   else if (! displayed)
1070     printf (_(" All options with the desired characteristics have already been displayed\n"));
1071
1072   putchar ('\n');
1073
1074   /* Print details of enumerated option arguments, if those
1075      enumerations have help text headings provided.  If no help text
1076      is provided, presume that the possible values are listed in the
1077      help text for the relevant options.  */
1078   for (i = 0; i < cl_enums_count; i++)
1079     {
1080       unsigned int j, pos;
1081
1082       if (opts->x_help_enum_printed[i] != 1)
1083         continue;
1084       if (cl_enums[i].help == NULL)
1085         continue;
1086       printf ("  %s\n    ", _(cl_enums[i].help));
1087       pos = 4;
1088       for (j = 0; cl_enums[i].values[j].arg != NULL; j++)
1089         {
1090           unsigned int len = strlen (cl_enums[i].values[j].arg);
1091
1092           if (pos > 4 && pos + 1 + len <= columns)
1093             {
1094               printf (" %s", cl_enums[i].values[j].arg);
1095               pos += 1 + len;
1096             }
1097           else
1098             {
1099               if (pos > 4)
1100                 {
1101                   printf ("\n    ");
1102                   pos = 4;
1103                 }
1104               printf ("%s", cl_enums[i].values[j].arg);
1105               pos += len;
1106             }
1107         }
1108       printf ("\n\n");
1109       opts->x_help_enum_printed[i] = 2;
1110     }
1111 }
1112
1113 /* Display help for a specified type of option.
1114    The options must have ALL of the INCLUDE_FLAGS set
1115    ANY of the flags in the ANY_FLAGS set
1116    and NONE of the EXCLUDE_FLAGS set.  The current option state is in
1117    OPTS; LANG_MASK is used for interpreting enumerated option state.  */
1118 static void
1119 print_specific_help (unsigned int include_flags,
1120                      unsigned int exclude_flags,
1121                      unsigned int any_flags,
1122                      struct gcc_options *opts,
1123                      unsigned int lang_mask)
1124 {
1125   unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1126   const char * description = NULL;
1127   const char * descrip_extra = "";
1128   size_t i;
1129   unsigned int flag;
1130
1131   /* Sanity check: Make sure that we do not have more
1132      languages than we have bits available to enumerate them.  */
1133   gcc_assert ((1U << cl_lang_count) <= CL_MIN_OPTION_CLASS);
1134
1135   /* If we have not done so already, obtain
1136      the desired maximum width of the output.  */
1137   if (opts->x_help_columns == 0)
1138     {
1139       const char *p;
1140
1141       p = getenv ("COLUMNS");
1142       if (p != NULL)
1143         {
1144           int value = atoi (p);
1145
1146           if (value > 0)
1147             opts->x_help_columns = value;
1148         }
1149
1150       if (opts->x_help_columns == 0)
1151         /* Use a reasonable default.  */
1152         opts->x_help_columns = 80;
1153     }
1154
1155   /* Decide upon the title for the options that we are going to display.  */
1156   for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1157     {
1158       switch (flag & include_flags)
1159         {
1160         case 0:
1161         case CL_DRIVER:
1162           break;
1163
1164         case CL_TARGET:
1165           description = _("The following options are target specific");
1166           break;
1167         case CL_WARNING:
1168           description = _("The following options control compiler warning messages");
1169           break;
1170         case CL_OPTIMIZATION:
1171           description = _("The following options control optimizations");
1172           break;
1173         case CL_COMMON:
1174           description = _("The following options are language-independent");
1175           break;
1176         case CL_PARAMS:
1177           description = _("The --param option recognizes the following as parameters");
1178           break;
1179         default:
1180           if (i >= cl_lang_count)
1181             break;
1182           if (exclude_flags & all_langs_mask)
1183             description = _("The following options are specific to just the language ");
1184           else
1185             description = _("The following options are supported by the language ");
1186           descrip_extra = lang_names [i];
1187           break;
1188         }
1189     }
1190
1191   if (description == NULL)
1192     {
1193       if (any_flags == 0)
1194         {
1195           if (include_flags & CL_UNDOCUMENTED)
1196             description = _("The following options are not documented");
1197           else if (include_flags & CL_SEPARATE)
1198             description = _("The following options take separate arguments");
1199           else if (include_flags & CL_JOINED)
1200             description = _("The following options take joined arguments");
1201           else
1202             {
1203               internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1204                               include_flags);
1205               return;
1206             }
1207         }
1208       else
1209         {
1210           if (any_flags & all_langs_mask)
1211             description = _("The following options are language-related");
1212           else
1213             description = _("The following options are language-independent");
1214         }
1215     }
1216
1217   printf ("%s%s:\n", description, descrip_extra);
1218   print_filtered_help (include_flags, exclude_flags, any_flags,
1219                        opts->x_help_columns, opts, lang_mask);
1220 }
1221
1222 /* Handle target- and language-independent options.  Return zero to
1223    generate an "unknown option" message.  Only options that need
1224    extra handling need to be listed here; if you simply want
1225    DECODED->value assigned to a variable, it happens automatically.  */
1226
1227 bool
1228 common_handle_option (struct gcc_options *opts,
1229                       struct gcc_options *opts_set,
1230                       const struct cl_decoded_option *decoded,
1231                       unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
1232                       location_t loc,
1233                       const struct cl_option_handlers *handlers,
1234                       diagnostic_context *dc)
1235 {
1236   size_t scode = decoded->opt_index;
1237   const char *arg = decoded->arg;
1238   int value = decoded->value;
1239   enum opt_code code = (enum opt_code) scode;
1240
1241   gcc_assert (decoded->canonical_option_num_elements <= 2);
1242
1243   switch (code)
1244     {
1245     case OPT__param:
1246       handle_param (opts, opts_set, loc, arg);
1247       break;
1248
1249     case OPT__help:
1250       {
1251         unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1252         unsigned int undoc_mask;
1253         unsigned int i;
1254
1255         if (lang_mask == CL_DRIVER)
1256           break;;
1257
1258         undoc_mask = ((opts->x_verbose_flag | opts->x_extra_warnings)
1259                       ? 0
1260                       : CL_UNDOCUMENTED);
1261         /* First display any single language specific options.  */
1262         for (i = 0; i < cl_lang_count; i++)
1263           print_specific_help
1264             (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0, opts,
1265              lang_mask);
1266         /* Next display any multi language specific options.  */
1267         print_specific_help (0, undoc_mask, all_langs_mask, opts, lang_mask);
1268         /* Then display any remaining, non-language options.  */
1269         for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1270           if (i != CL_DRIVER)
1271             print_specific_help (i, undoc_mask, 0, opts, lang_mask);
1272         opts->x_exit_after_options = true;
1273         break;
1274       }
1275
1276     case OPT__target_help:
1277       if (lang_mask == CL_DRIVER)
1278         break;
1279
1280       print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0, opts, lang_mask);
1281       opts->x_exit_after_options = true;
1282       break;
1283
1284     case OPT__help_:
1285       {
1286         const char * a = arg;
1287         unsigned int include_flags = 0;
1288         /* Note - by default we include undocumented options when listing
1289            specific classes.  If you only want to see documented options
1290            then add ",^undocumented" to the --help= option.  E.g.:
1291
1292            --help=target,^undocumented  */
1293         unsigned int exclude_flags = 0;
1294
1295         if (lang_mask == CL_DRIVER)
1296           break;
1297
1298         /* Walk along the argument string, parsing each word in turn.
1299            The format is:
1300            arg = [^]{word}[,{arg}]
1301            word = {optimizers|target|warnings|undocumented|
1302                    params|common|<language>}  */
1303         while (* a != 0)
1304           {
1305             static const struct
1306             {
1307               const char * string;
1308               unsigned int flag;
1309             }
1310             specifics[] =
1311             {
1312               { "optimizers", CL_OPTIMIZATION },
1313               { "target", CL_TARGET },
1314               { "warnings", CL_WARNING },
1315               { "undocumented", CL_UNDOCUMENTED },
1316               { "params", CL_PARAMS },
1317               { "joined", CL_JOINED },
1318               { "separate", CL_SEPARATE },
1319               { "common", CL_COMMON },
1320               { NULL, 0 }
1321             };
1322             unsigned int * pflags;
1323             const char * comma;
1324             unsigned int lang_flag, specific_flag;
1325             unsigned int len;
1326             unsigned int i;
1327
1328             if (* a == '^')
1329               {
1330                 ++ a;
1331                 pflags = & exclude_flags;
1332               }
1333             else
1334               pflags = & include_flags;
1335
1336             comma = strchr (a, ',');
1337             if (comma == NULL)
1338               len = strlen (a);
1339             else
1340               len = comma - a;
1341             if (len == 0)
1342               {
1343                 a = comma + 1;
1344                 continue;
1345               }
1346
1347             /* Check to see if the string matches an option class name.  */
1348             for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1349               if (strncasecmp (a, specifics[i].string, len) == 0)
1350                 {
1351                   specific_flag = specifics[i].flag;
1352                   break;
1353                 }
1354
1355             /* Check to see if the string matches a language name.
1356                Note - we rely upon the alpha-sorted nature of the entries in
1357                the lang_names array, specifically that shorter names appear
1358                before their longer variants.  (i.e. C before C++).  That way
1359                when we are attempting to match --help=c for example we will
1360                match with C first and not C++.  */
1361             for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1362               if (strncasecmp (a, lang_names[i], len) == 0)
1363                 {
1364                   lang_flag = 1U << i;
1365                   break;
1366                 }
1367
1368             if (specific_flag != 0)
1369               {
1370                 if (lang_flag == 0)
1371                   * pflags |= specific_flag;
1372                 else
1373                   {
1374                     /* The option's argument matches both the start of a
1375                        language name and the start of an option class name.
1376                        We have a special case for when the user has
1377                        specified "--help=c", but otherwise we have to issue
1378                        a warning.  */
1379                     if (strncasecmp (a, "c", len) == 0)
1380                       * pflags |= lang_flag;
1381                     else
1382                       warning_at (loc, 0,
1383                                   "--help argument %q.*s is ambiguous, "
1384                                   "please be more specific",
1385                                   len, a);
1386                   }
1387               }
1388             else if (lang_flag != 0)
1389               * pflags |= lang_flag;
1390             else
1391               warning_at (loc, 0,
1392                           "unrecognized argument to --help= option: %q.*s",
1393                           len, a);
1394
1395             if (comma == NULL)
1396               break;
1397             a = comma + 1;
1398           }
1399
1400         if (include_flags)
1401           print_specific_help (include_flags, exclude_flags, 0, opts,
1402                                lang_mask);
1403         opts->x_exit_after_options = true;
1404         break;
1405       }
1406
1407     case OPT__version:
1408       if (lang_mask == CL_DRIVER)
1409         break;
1410
1411       opts->x_exit_after_options = true;
1412       break;
1413
1414     case OPT_O:
1415     case OPT_Os:
1416     case OPT_Ofast:
1417       /* Currently handled in a prescan.  */
1418       break;
1419
1420     case OPT_Werror_:
1421       if (lang_mask == CL_DRIVER)
1422         break;
1423
1424       enable_warning_as_error (arg, value, lang_mask, handlers,
1425                                opts, opts_set, loc, dc);
1426       break;
1427
1428     case OPT_Wlarger_than_:
1429       opts->x_larger_than_size = value;
1430       opts->x_warn_larger_than = value != -1;
1431       break;
1432
1433     case OPT_Wfatal_errors:
1434       dc->fatal_errors = value;
1435       break;
1436
1437     case OPT_Wframe_larger_than_:
1438       opts->x_frame_larger_than_size = value;
1439       opts->x_warn_frame_larger_than = value != -1;
1440       break;
1441
1442     case OPT_Wstack_usage_:
1443       opts->x_warn_stack_usage = value;
1444       opts->x_flag_stack_usage_info = value != -1;
1445       break;
1446
1447     case OPT_Wstrict_aliasing:
1448       set_Wstrict_aliasing (opts, value);
1449       break;
1450
1451     case OPT_Wstrict_overflow:
1452       opts->x_warn_strict_overflow = (value
1453                                       ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1454                                       : 0);
1455       break;
1456
1457     case OPT_Wsystem_headers:
1458       dc->dc_warn_system_headers = value;
1459       break;
1460
1461     case OPT_aux_info:
1462       opts->x_flag_gen_aux_info = 1;
1463       break;
1464
1465     case OPT_auxbase_strip:
1466       {
1467         char *tmp = xstrdup (arg);
1468         strip_off_ending (tmp, strlen (tmp));
1469         if (tmp[0])
1470           opts->x_aux_base_name = tmp;
1471       }
1472       break;
1473
1474     case OPT_d:
1475       decode_d_option (arg, opts, loc, dc);
1476       break;
1477
1478     case OPT_fcall_used_:
1479     case OPT_fcall_saved_:
1480       /* Deferred.  */
1481       break;
1482
1483     case OPT_fdbg_cnt_:
1484     case OPT_fdbg_cnt_list:
1485       /* Deferred.  */
1486       break;
1487
1488     case OPT_fdebug_prefix_map_:
1489       /* Deferred.  */
1490       break;
1491
1492     case OPT_fdiagnostics_show_location_:
1493       diagnostic_prefixing_rule (dc) = (diagnostic_prefixing_rule_t) value;
1494       break;
1495
1496     case OPT_fdiagnostics_show_option:
1497       dc->show_option_requested = value;
1498       break;
1499
1500     case OPT_fdump_:
1501       /* Deferred.  */
1502       break;
1503
1504     case OPT_ffast_math:
1505       set_fast_math_flags (opts, value);
1506       break;
1507
1508     case OPT_funsafe_math_optimizations:
1509       set_unsafe_math_optimizations_flags (opts, value);
1510       break;
1511
1512     case OPT_ffixed_:
1513       /* Deferred.  */
1514       break;
1515
1516     case OPT_finline_limit_:
1517       set_param_value ("max-inline-insns-single", value / 2,
1518                        opts->x_param_values, opts_set->x_param_values);
1519       set_param_value ("max-inline-insns-auto", value / 2,
1520                        opts->x_param_values, opts_set->x_param_values);
1521       break;
1522
1523     case OPT_finstrument_functions_exclude_function_list_:
1524       add_comma_separated_to_vector
1525         (&opts->x_flag_instrument_functions_exclude_functions, arg);
1526       break;
1527
1528     case OPT_finstrument_functions_exclude_file_list_:
1529       add_comma_separated_to_vector
1530         (&opts->x_flag_instrument_functions_exclude_files, arg);
1531       break;
1532
1533     case OPT_fmessage_length_:
1534       pp_set_line_maximum_length (dc->printer, value);
1535       break;
1536
1537     case OPT_fpack_struct_:
1538       if (value <= 0 || (value & (value - 1)) || value > 16)
1539         error_at (loc,
1540                   "structure alignment must be a small power of two, not %d",
1541                   value);
1542       else
1543         opts->x_initial_max_fld_align = value;
1544       break;
1545
1546     case OPT_fplugin_:
1547     case OPT_fplugin_arg_:
1548       /* Deferred.  */
1549       break;
1550
1551     case OPT_fprofile_use_:
1552       opts->x_profile_data_prefix = xstrdup (arg);
1553       opts->x_flag_profile_use = true;
1554       value = true;
1555       /* No break here - do -fprofile-use processing. */
1556     case OPT_fprofile_use:
1557       if (!opts_set->x_flag_branch_probabilities)
1558         opts->x_flag_branch_probabilities = value;
1559       if (!opts_set->x_flag_profile_values)
1560         opts->x_flag_profile_values = value;
1561       if (!opts_set->x_flag_unroll_loops)
1562         opts->x_flag_unroll_loops = value;
1563       if (!opts_set->x_flag_peel_loops)
1564         opts->x_flag_peel_loops = value;
1565       if (!opts_set->x_flag_tracer)
1566         opts->x_flag_tracer = value;
1567       if (!opts_set->x_flag_value_profile_transformations)
1568         opts->x_flag_value_profile_transformations = value;
1569       if (!opts_set->x_flag_inline_functions)
1570         opts->x_flag_inline_functions = value;
1571       if (!opts_set->x_flag_ipa_cp)
1572         opts->x_flag_ipa_cp = value;
1573       if (!opts_set->x_flag_ipa_cp_clone
1574           && value && opts->x_flag_ipa_cp)
1575         opts->x_flag_ipa_cp_clone = value;
1576       if (!opts_set->x_flag_predictive_commoning)
1577         opts->x_flag_predictive_commoning = value;
1578       if (!opts_set->x_flag_unswitch_loops)
1579         opts->x_flag_unswitch_loops = value;
1580       if (!opts_set->x_flag_gcse_after_reload)
1581         opts->x_flag_gcse_after_reload = value;
1582       break;
1583
1584     case OPT_fprofile_generate_:
1585       opts->x_profile_data_prefix = xstrdup (arg);
1586       value = true;
1587       /* No break here - do -fprofile-generate processing. */
1588     case OPT_fprofile_generate:
1589       if (!opts_set->x_profile_arc_flag)
1590         opts->x_profile_arc_flag = value;
1591       if (!opts_set->x_flag_profile_values)
1592         opts->x_flag_profile_values = value;
1593       if (!opts_set->x_flag_value_profile_transformations)
1594         opts->x_flag_value_profile_transformations = value;
1595       if (!opts_set->x_flag_inline_functions)
1596         opts->x_flag_inline_functions = value;
1597       /* FIXME: Instrumentation we insert makes ipa-reference bitmaps
1598          quadratic.  Disable the pass until better memory representation
1599          is done.  */
1600       if (!opts_set->x_flag_ipa_reference && opts->x_in_lto_p)
1601         opts->x_flag_ipa_reference = false;
1602       break;
1603
1604     case OPT_fshow_column:
1605       dc->show_column = value;
1606       break;
1607
1608     case OPT_frandom_seed:
1609       /* The real switch is -fno-random-seed.  */
1610       if (value)
1611         return false;
1612       /* Deferred.  */
1613       break;
1614
1615     case OPT_frandom_seed_:
1616       /* Deferred.  */
1617       break;
1618
1619     case OPT_fsched_verbose_:
1620 #ifdef INSN_SCHEDULING
1621       /* Handled with Var in common.opt.  */
1622       break;
1623 #else
1624       return false;
1625 #endif
1626
1627     case OPT_fsched_stalled_insns_:
1628       opts->x_flag_sched_stalled_insns = value;
1629       if (opts->x_flag_sched_stalled_insns == 0)
1630         opts->x_flag_sched_stalled_insns = -1;
1631       break;
1632
1633     case OPT_fsched_stalled_insns_dep_:
1634       opts->x_flag_sched_stalled_insns_dep = value;
1635       break;
1636
1637     case OPT_fstack_check_:
1638       if (!strcmp (arg, "no"))
1639         opts->x_flag_stack_check = NO_STACK_CHECK;
1640       else if (!strcmp (arg, "generic"))
1641         /* This is the old stack checking method.  */
1642         opts->x_flag_stack_check = STACK_CHECK_BUILTIN
1643                            ? FULL_BUILTIN_STACK_CHECK
1644                            : GENERIC_STACK_CHECK;
1645       else if (!strcmp (arg, "specific"))
1646         /* This is the new stack checking method.  */
1647         opts->x_flag_stack_check = STACK_CHECK_BUILTIN
1648                            ? FULL_BUILTIN_STACK_CHECK
1649                            : STACK_CHECK_STATIC_BUILTIN
1650                              ? STATIC_BUILTIN_STACK_CHECK
1651                              : GENERIC_STACK_CHECK;
1652       else
1653         warning_at (loc, 0, "unknown stack check parameter \"%s\"", arg);
1654       break;
1655
1656     case OPT_fstack_limit:
1657       /* The real switch is -fno-stack-limit.  */
1658       if (value)
1659         return false;
1660       /* Deferred.  */
1661       break;
1662
1663     case OPT_fstack_limit_register_:
1664     case OPT_fstack_limit_symbol_:
1665       /* Deferred.  */
1666       break;
1667
1668     case OPT_fstack_usage:
1669       opts->x_flag_stack_usage = value;
1670       opts->x_flag_stack_usage_info = value != 0;
1671       break;
1672
1673     case OPT_ftree_vectorizer_verbose_:
1674       vect_set_verbosity_level (opts, value);
1675       break;
1676
1677     case OPT_g:
1678       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg, opts, opts_set,
1679                        loc);
1680       break;
1681
1682     case OPT_gcoff:
1683       set_debug_level (SDB_DEBUG, false, arg, opts, opts_set, loc);
1684       break;
1685
1686     case OPT_gdwarf_:
1687       if (value < 2 || value > 4)
1688         error_at (loc, "dwarf version %d is not supported", value);
1689       else
1690         opts->x_dwarf_version = value;
1691       set_debug_level (DWARF2_DEBUG, false, "", opts, opts_set, loc);
1692       break;
1693
1694     case OPT_ggdb:
1695       set_debug_level (NO_DEBUG, 2, arg, opts, opts_set, loc);
1696       break;
1697
1698     case OPT_gstabs:
1699     case OPT_gstabs_:
1700       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg, opts, opts_set,
1701                        loc);
1702       break;
1703
1704     case OPT_gvms:
1705       set_debug_level (VMS_DEBUG, false, arg, opts, opts_set, loc);
1706       break;
1707
1708     case OPT_gxcoff:
1709     case OPT_gxcoff_:
1710       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg, opts, opts_set,
1711                        loc);
1712       break;
1713
1714     case OPT_pedantic_errors:
1715       opts->x_pedantic = 1;
1716       dc->pedantic_errors = 1;
1717       break;
1718
1719     case OPT_flto:
1720       opts->x_flag_lto = value ? "" : NULL;
1721       break;
1722
1723     case OPT_w:
1724       dc->dc_inhibit_warnings = true;
1725       break;
1726
1727     case OPT_fmax_errors_:
1728       dc->max_errors = value;
1729       break;
1730
1731     case OPT_fuse_linker_plugin:
1732       /* No-op. Used by the driver and passed to us because it starts with f.*/
1733       break;
1734
1735     case OPT_Wuninitialized:
1736       /* Also turn on maybe uninitialized warning.  */
1737       opts->x_warn_maybe_uninitialized = value;
1738       break;
1739
1740     default:
1741       /* If the flag was handled in a standard way, assume the lack of
1742          processing here is intentional.  */
1743       gcc_assert (option_flag_var (scode, opts));
1744       break;
1745     }
1746
1747   return true;
1748 }
1749
1750 /* Handle --param NAME=VALUE.  */
1751 static void
1752 handle_param (struct gcc_options *opts, struct gcc_options *opts_set,
1753               location_t loc, const char *carg)
1754 {
1755   char *equal, *arg;
1756   int value;
1757
1758   arg = xstrdup (carg);
1759   equal = strchr (arg, '=');
1760   if (!equal)
1761     error_at (loc, "%s: --param arguments should be of the form NAME=VALUE",
1762               arg);
1763   else
1764     {
1765       value = integral_argument (equal + 1);
1766       if (value == -1)
1767         error_at (loc, "invalid --param value %qs", equal + 1);
1768       else
1769         {
1770           *equal = '\0';
1771           set_param_value (arg, value,
1772                            opts->x_param_values, opts_set->x_param_values);
1773         }
1774     }
1775
1776   free (arg);
1777 }
1778
1779 /* Used to set the level of strict aliasing warnings in OPTS,
1780    when no level is specified (i.e., when -Wstrict-aliasing, and not
1781    -Wstrict-aliasing=level was given).
1782    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
1783    and 0 otherwise.  After calling this function, wstrict_aliasing will be
1784    set to the default value of -Wstrict_aliasing=level, currently 3.  */
1785 void
1786 set_Wstrict_aliasing (struct gcc_options *opts, int onoff)
1787 {
1788   gcc_assert (onoff == 0 || onoff == 1);
1789   if (onoff != 0)
1790     opts->x_warn_strict_aliasing = 3;
1791   else
1792     opts->x_warn_strict_aliasing = 0;
1793 }
1794
1795 /* The following routines are useful in setting all the flags that
1796    -ffast-math and -fno-fast-math imply.  */
1797 static void
1798 set_fast_math_flags (struct gcc_options *opts, int set)
1799 {
1800   if (!opts->frontend_set_flag_unsafe_math_optimizations)
1801     {
1802       opts->x_flag_unsafe_math_optimizations = set;
1803       set_unsafe_math_optimizations_flags (opts, set);
1804     }
1805   if (!opts->frontend_set_flag_finite_math_only)
1806     opts->x_flag_finite_math_only = set;
1807   if (!opts->frontend_set_flag_errno_math)
1808     opts->x_flag_errno_math = !set;
1809   if (set)
1810     {
1811       if (!opts->frontend_set_flag_signaling_nans)
1812         opts->x_flag_signaling_nans = 0;
1813       if (!opts->frontend_set_flag_rounding_math)
1814         opts->x_flag_rounding_math = 0;
1815       if (!opts->frontend_set_flag_cx_limited_range)
1816         opts->x_flag_cx_limited_range = 1;
1817     }
1818 }
1819
1820 /* When -funsafe-math-optimizations is set the following
1821    flags are set as well.  */
1822 static void
1823 set_unsafe_math_optimizations_flags (struct gcc_options *opts, int set)
1824 {
1825   if (!opts->frontend_set_flag_trapping_math)
1826     opts->x_flag_trapping_math = !set;
1827   if (!opts->frontend_set_flag_signed_zeros)
1828     opts->x_flag_signed_zeros = !set;
1829   if (!opts->frontend_set_flag_associative_math)
1830     opts->x_flag_associative_math = set;
1831   if (!opts->frontend_set_flag_reciprocal_math)
1832     opts->x_flag_reciprocal_math = set;
1833 }
1834
1835 /* Return true iff flags in OPTS are set as if -ffast-math.  */
1836 bool
1837 fast_math_flags_set_p (const struct gcc_options *opts)
1838 {
1839   return (!opts->x_flag_trapping_math
1840           && opts->x_flag_unsafe_math_optimizations
1841           && opts->x_flag_finite_math_only
1842           && !opts->x_flag_signed_zeros
1843           && !opts->x_flag_errno_math);
1844 }
1845
1846 /* Return true iff flags are set as if -ffast-math but using the flags stored
1847    in the struct cl_optimization structure.  */
1848 bool
1849 fast_math_flags_struct_set_p (struct cl_optimization *opt)
1850 {
1851   return (!opt->x_flag_trapping_math
1852           && opt->x_flag_unsafe_math_optimizations
1853           && opt->x_flag_finite_math_only
1854           && !opt->x_flag_signed_zeros
1855           && !opt->x_flag_errno_math);
1856 }
1857
1858 /* Handle a debug output -g switch for options OPTS
1859    (OPTS_SET->x_write_symbols storing whether a debug type was passed
1860    explicitly), location LOC.  EXTENDED is true or false to support
1861    extended output (2 is special and means "-ggdb" was given).  */
1862 static void
1863 set_debug_level (enum debug_info_type type, int extended, const char *arg,
1864                  struct gcc_options *opts, struct gcc_options *opts_set,
1865                  location_t loc)
1866 {
1867   opts->x_use_gnu_debug_info_extensions = extended;
1868
1869   if (type == NO_DEBUG)
1870     {
1871       if (opts->x_write_symbols == NO_DEBUG)
1872         {
1873           opts->x_write_symbols = PREFERRED_DEBUGGING_TYPE;
1874
1875           if (extended == 2)
1876             {
1877 #ifdef DWARF2_DEBUGGING_INFO
1878               opts->x_write_symbols = DWARF2_DEBUG;
1879 #elif defined DBX_DEBUGGING_INFO
1880               opts->x_write_symbols = DBX_DEBUG;
1881 #endif
1882             }
1883
1884           if (opts->x_write_symbols == NO_DEBUG)
1885             warning_at (loc, 0, "target system does not support debug output");
1886         }
1887     }
1888   else
1889     {
1890       /* Does it conflict with an already selected type?  */
1891       if (opts_set->x_write_symbols != NO_DEBUG
1892           && opts->x_write_symbols != NO_DEBUG
1893           && type != opts->x_write_symbols)
1894         error_at (loc, "debug format \"%s\" conflicts with prior selection",
1895                   debug_type_names[type]);
1896       opts->x_write_symbols = type;
1897       opts_set->x_write_symbols = type;
1898     }
1899
1900   /* A debug flag without a level defaults to level 2.  */
1901   if (*arg == '\0')
1902     {
1903       if (!opts->x_debug_info_level)
1904         opts->x_debug_info_level = DINFO_LEVEL_NORMAL;
1905     }
1906   else
1907     {
1908       int argval = integral_argument (arg);
1909       if (argval == -1)
1910         error_at (loc, "unrecognised debug output level \"%s\"", arg);
1911       else if (argval > 3)
1912         error_at (loc, "debug output level %s is too high", arg);
1913       else
1914         opts->x_debug_info_level = (enum debug_info_levels) argval;
1915     }
1916 }
1917
1918 /* Arrange to dump core on error for diagnostic context DC.  (The
1919    regular error message is still printed first, except in the case of
1920    abort ().)  */
1921
1922 static void
1923 setup_core_dumping (diagnostic_context *dc)
1924 {
1925 #ifdef SIGABRT
1926   signal (SIGABRT, SIG_DFL);
1927 #endif
1928 #if defined(HAVE_SETRLIMIT)
1929   {
1930     struct rlimit rlim;
1931     if (getrlimit (RLIMIT_CORE, &rlim) != 0)
1932       fatal_error ("getting core file size maximum limit: %m");
1933     rlim.rlim_cur = rlim.rlim_max;
1934     if (setrlimit (RLIMIT_CORE, &rlim) != 0)
1935       fatal_error ("setting core file size limit to maximum: %m");
1936   }
1937 #endif
1938   diagnostic_abort_on_error (dc);
1939 }
1940
1941 /* Parse a -d<ARG> command line switch for OPTS, location LOC,
1942    diagnostic context DC.  */
1943
1944 static void
1945 decode_d_option (const char *arg, struct gcc_options *opts,
1946                  location_t loc, diagnostic_context *dc)
1947 {
1948   int c;
1949
1950   while (*arg)
1951     switch (c = *arg++)
1952       {
1953       case 'A':
1954         opts->x_flag_debug_asm = 1;
1955         break;
1956       case 'p':
1957         opts->x_flag_print_asm_name = 1;
1958         break;
1959       case 'P':
1960         opts->x_flag_dump_rtl_in_asm = 1;
1961         opts->x_flag_print_asm_name = 1;
1962         break;
1963       case 'v':
1964         opts->x_graph_dump_format = vcg;
1965         break;
1966       case 'x':
1967         opts->x_rtl_dump_and_exit = 1;
1968         break;
1969       case 'D': /* These are handled by the preprocessor.  */
1970       case 'I':
1971       case 'M':
1972       case 'N':
1973       case 'U':
1974         break;
1975       case 'H':
1976         setup_core_dumping (dc);
1977         break;
1978       case 'a':
1979         opts->x_flag_dump_all_passed = true;
1980         break;
1981
1982       default:
1983           warning_at (loc, 0, "unrecognized gcc debugging option: %c", c);
1984         break;
1985       }
1986 }
1987
1988 /* Enable (or disable if VALUE is 0) a warning option ARG (language
1989    mask LANG_MASK, option handlers HANDLERS) as an error for option
1990    structures OPTS and OPTS_SET, diagnostic context DC (possibly
1991    NULL), location LOC.  This is used by -Werror=.  */
1992
1993 static void
1994 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
1995                          const struct cl_option_handlers *handlers,
1996                          struct gcc_options *opts,
1997                          struct gcc_options *opts_set,
1998                          location_t loc, diagnostic_context *dc)
1999 {
2000   char *new_option;
2001   int option_index;
2002
2003   new_option = XNEWVEC (char, strlen (arg) + 2);
2004   new_option[0] = 'W';
2005   strcpy (new_option + 1, arg);
2006   option_index = find_opt (new_option, lang_mask);
2007   if (option_index == OPT_SPECIAL_unknown)
2008     {
2009       error_at (loc, "-Werror=%s: no option -%s", arg, new_option);
2010     }
2011   else
2012     {
2013       const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
2014
2015       control_warning_option (option_index, (int) kind, value,
2016                               loc, lang_mask,
2017                               handlers, opts, opts_set, dc);
2018       if (option_index == OPT_Wuninitialized)
2019         enable_warning_as_error ("maybe-uninitialized", value, lang_mask,
2020                                  handlers, opts, opts_set, loc, dc);
2021     }
2022   free (new_option);
2023 }
2024
2025 /* Return malloced memory for the name of the option OPTION_INDEX
2026    which enabled a diagnostic (context CONTEXT), originally of type
2027    ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
2028    as -Werror.  */
2029
2030 char *
2031 option_name (diagnostic_context *context, int option_index,
2032              diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
2033 {
2034   if (option_index)
2035     {
2036       /* A warning classified as an error.  */
2037       if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
2038           && diag_kind == DK_ERROR)
2039         return concat (cl_options[OPT_Werror_].opt_text,
2040                        /* Skip over "-W".  */
2041                        cl_options[option_index].opt_text + 2,
2042                        NULL);
2043       /* A warning with option.  */
2044       else
2045         return xstrdup (cl_options[option_index].opt_text);
2046     }
2047   /* A warning without option classified as an error.  */
2048   else if (orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
2049            || diag_kind == DK_WARNING)
2050     {
2051       if (context->warning_as_error_requested)
2052         return xstrdup (cl_options[OPT_Werror].opt_text);
2053       else
2054         return xstrdup (_("enabled by default"));
2055     }
2056   else
2057     return NULL;
2058 }